home *** CD-ROM | disk | FTP | other *** search
/ Programming a Multiplayer FPS in DirectX / Programming a Multiplayer FPS in DirectX (Companion CD).iso / DirectX / dxsdk_oct2004.exe / dxsdk.exe / Utilities / Content Creation Tool Plug-Ins / Maya / Sources / XExporter.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2004-09-27  |  101.0 KB  |  4,050 lines
  1.  
  2.  
  3. #include "dxstdafx.h"
  4.  
  5. #include "d3d9.h"
  6. #include "d3dx9.h"
  7.  
  8. #include "MayaInterface.h"
  9. #include "XExporter.h"
  10.  
  11.  
  12. #include "PreviewPipeline.h"
  13. #include "MayaInterface.h"
  14. #include <windows.h>
  15. #include <assert.h>
  16. #include <stdio.h>
  17. #include <memory.h>
  18. #include <string.h>
  19. #include <wchar.h>
  20. #include <stdlib.h>
  21. #include <math.h>
  22. #include <malloc.h>
  23.  
  24. // Maya API
  25. #include <maya/MSelectionList.h>
  26.  
  27. //#include <maya/MFn.h>
  28. //#include <maya/MFnDependencyNode.h>
  29. #include <maya/MObject.h>
  30. #include <maya/MPxNode.h>
  31. #include <maya/MFnDagNode.h>
  32. #include <maya/MDagPath.h>
  33. #include <maya/MDagPathArray.h>
  34. #include <maya/MPlug.h>
  35. #include <maya/MItDag.h>
  36.  
  37. #include <maya/MColor.h>
  38. #include <maya/MMatrix.h>
  39. #include <maya/MQuaternion.h>
  40. #include <maya/MTime.h>
  41.  
  42. #include <maya/MFnMeshData.h>
  43. #include <maya/MIntArray.h>
  44. #include <maya/MFloatArray.h>
  45. #include <maya/MFloatVectorArray.h>
  46. #include <maya/MFloatPointArray.h>
  47. #include <maya/MPointArray.h>
  48. #include <maya/MObjectArray.h>
  49. #include <maya/MDagPathArray.h>
  50. #include <maya/MPlugArray.h>
  51. #include <maya/MFnCompoundAttribute.h>
  52. #include <maya/MFnTypedAttribute.h>
  53. #include <maya/MFnNumericAttribute.h>
  54. #include <maya/MTransformationMatrix.h>
  55. #include <maya/MFnMatrixAttribute.h>
  56. #include <maya/MSceneMessage.h>
  57. #include <maya/MDGMessage.h>
  58. #include <maya/MNodeMessage.h>
  59. #include <maya/MDagMessage.h>
  60. #include <maya/MEventMessage.h>
  61. #include <maya/MFnCamera.h>
  62. #include <maya/MAnimMessage.h>
  63.  
  64. //#include <maya/MSimple.h>
  65. //#include <maya/MEulerRotation.h>
  66. //#include <maya/MIkSystem.h>
  67.  
  68. #include <maya/MAnimControl.h>
  69. #include <maya/MAnimUtil.h>
  70.  
  71. #include <maya/MFnTransform.h>
  72. #include <maya/MFnIKJoint.h>
  73. #include <maya/MFnMesh.h>
  74. #include <maya/MFnNurbsSurface.h>
  75. #include <maya/MFnSubd.h>
  76. #include <maya/MFnLambertShader.h>
  77. #include <maya/MFnBlinnShader.h>
  78. #include <maya/MFnPhongShader.h>
  79. #include <maya/MFnSkinCluster.h>
  80. #include <maya/MFnWeightGeometryFilter.h>
  81. #include <maya/MFnBlendShapeDeformer.h>
  82. #include <maya/MFnMatrixData.h>
  83. #include <maya/MFnSet.h>
  84. #include <maya/MFnDoubleArrayData.h>
  85. #include <maya/MFnStringData.h>
  86.  
  87. #include <maya/MItDag.h>
  88. #include <maya/MItSelectionList.h>
  89. #include <maya/MItDependencyGraph.h>
  90. #include <maya/MItDependencyNodes.h>
  91. #include <maya/MItGeometry.h>
  92. #include <maya/MItMeshPolygon.h>
  93. #include <maya/MItMeshVertex.h>
  94. #include <maya/MItMeshFaceVertex.h>
  95.  
  96.  
  97. CRITICAL_SECTION DeviceAndViewerSection; 
  98. HANDLE DeviceCreatedEvent; 
  99. //HANDLE CreationSemaphore;
  100. //HANDLE CreationThread;
  101. //HANDLE UpdateThread;
  102.  
  103. CMayaPreviewPipeline g_PreviewPipeline;
  104.  
  105. struct _MeshGlobal
  106. {
  107.     CAtlArray<DWORD>                D3DPointReps;
  108.     CAtlArray<VertexD3DToMayaType>    VertexD3DToMaya;
  109.     CAtlArray<VertexMayaToD3DType>    VertexMayaToD3D;
  110.  
  111. } MeshGlobal;
  112.  
  113.  
  114. CMayaPreviewPipeline::CMayaPreviewPipeline()
  115. {
  116.     new(&TagContainer) DCCTagContainer(this);
  117. };
  118.  
  119. CMayaPreviewPipeline::~CMayaPreviewPipeline()
  120. {
  121. }; 
  122.  
  123. HRESULT CMayaPreviewPipeline::Synchronize_Material(DXCCHANDLE hDirtyShader)
  124. {
  125.     HRESULT hr= S_OK;
  126.     MStatus stat= MS::kSuccess;
  127.  
  128.     MObject node= Convert_DXCCResourceToDGNode(hDirtyShader);
  129.     if(!node.isNull())
  130.     {
  131.         for(MItDependencyGraph FindEngine(node, MFn::kShadingEngine, MItDependencyGraph::kDownstream );
  132.             !FindEngine.isDone();
  133.             FindEngine.next())
  134.         {
  135.             MObject dgShadingEngine= FindEngine.thisNode();
  136.  
  137.             if(!dgShadingEngine.isNull())
  138.             {
  139.  
  140.  
  141.  
  142.                 for(MItDependencyGraph FindMesh(dgShadingEngine, MFn::kMesh, MItDependencyGraph::kUpstream);
  143.                     !FindMesh.isDone();
  144.                     FindMesh.next())
  145.                 {
  146.                     MObject dgMesh= FindMesh.thisNode();
  147.                     if(!dgMesh.isNull())
  148.                     {
  149.                         MDagPathArray PathArray;
  150.  
  151.                         MDagPath::getAllPathsTo(dgMesh, PathArray);
  152.                         for(UINT iPath= 0; iPath < PathArray.length(); iPath++)
  153.                         {
  154.                             DCCTag* tag= NULL;
  155.                             if(TagContainer.Find(PathArray[iPath], NULL, &tag))
  156.                             {
  157.                                 TagContainer.MarkAsDirty(tag);
  158.                             }
  159.                         }
  160.                     }
  161.                 }
  162.  
  163.  
  164.             }
  165.         }
  166.     }
  167.     return hr;
  168. }
  169.  
  170. MObject CMayaPreviewPipeline::Convert_DXCCResourceToDGNode(DXCCHANDLE matchHandle)
  171. {
  172.     for(MItDependencyNodes iter; !iter.isDone(); iter.next())
  173.     {
  174.         MFnDependencyNode depNode(iter.item());
  175.         if(depNode.typeId() == DirectXShader::id)
  176.         {
  177.             int iHandle;
  178.             DXCCHANDLE hHandle; 
  179.  
  180.             MPlug plugResource= depNode.findPlug(DirectXShader::aDXCCHandle);
  181.  
  182.             plugResource.getValue(iHandle);
  183.             hHandle= (DXCCHANDLE)iHandle;
  184.  
  185.             if(hHandle == matchHandle)
  186.             {
  187.                 return iter.item();
  188.             }
  189.         }
  190.     }
  191.  
  192.     return MObject();
  193. }
  194.  
  195.  
  196. DXCCHANDLE CMayaPreviewPipeline::Convert_DGNodeToDXCCResource(MObject matchNode)
  197. {
  198.     MFnDependencyNode depNode(matchNode);
  199.     if(depNode.typeId() == DirectXShader::id)
  200.     {
  201.         int iHandle;
  202.         DXCCHANDLE hHandle; 
  203.  
  204.         MPlug plugResource= depNode.findPlug(DirectXShader::aDXCCHandle);
  205.  
  206.         plugResource.getValue(iHandle);
  207.         hHandle= (DXCCHANDLE)iHandle;
  208.  
  209.         return hHandle;
  210.     }
  211.  
  212.     return NULL;
  213. }
  214.  
  215.  
  216.  
  217.  
  218. HRESULT CDXCCSaveEffectDefaults::Set(LPDXCCMANAGER pResourceManager, /*MObject& attribParameters,*/ MObject& pxNode)
  219. {
  220.     if(!pResourceManager)
  221.         return E_INVALIDARG;
  222.  
  223.     if(pxNode.isNull())
  224.         return E_INVALIDARG;
  225.  
  226.     //if(attribParameters.isNull())
  227.     //    return E_INVALIDARG;
  228.  
  229.     pManager= pResourceManager;
  230.     oNode= pxNode;
  231.     //aEffectParameters= attribParameters;
  232.     iParameter= 0;
  233.  
  234.     return S_OK;
  235. };
  236.  
  237. HRESULT CDXCCSaveEffectDefaults::EnumParameter(LPD3DXEFFECT pEffect, PathInfo& parameter)
  238. {
  239.     HRESULT hr= S_OK;
  240.     MStatus stat= MS::kSuccess;
  241.  
  242.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  243.  
  244.     bool Valid= false;
  245.     MPlug plugName;
  246.     MFnTypedAttribute aParamName;
  247.     MFnTypedAttribute aParamValue;
  248.     MObject oParamValue;
  249.     MFnDependencyNode depNode(oNode);
  250.     FLOAT fArray[16];
  251.  
  252.     if(!pManager)
  253.         return E_UNEXPECTED;
  254.  
  255.     if(oNode.isNull())
  256.         return E_INVALIDARG;
  257.  
  258.  
  259.     MString ShortParamName( MString(DX_SHORT_FXPARAM_NAME) + iParameter);
  260.     MString LongParamName( MString(DX_LONG_FXPARAM_NAME) + iParameter);
  261.     MString ShortDataName( MString(DX_SHORT_FXPARAM_DATA) + iParameter);
  262.     MString LongDataName( MString(DX_LONG_FXPARAM_DATA) + iParameter);
  263.  
  264.  
  265.     plugName= depNode.findPlug(LongParamName);
  266.     if(plugName.isNull())
  267.     {
  268.         MObject oParamName= aParamName.create(LongParamName, ShortParamName, MFnData::kString, MObject::kNullObj , &stat);
  269.         if(MAYA_FAILED(stat))
  270.             DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  271.  
  272.         CHECK_MSTATUS( aParamName.setHidden( true ) );
  273.  
  274.         stat = depNode.addAttribute(oParamName);
  275.         if(MAYA_FAILED(stat))
  276.             DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  277.  
  278.         plugName= depNode.findPlug(LongParamName, &stat);
  279.         if(MAYA_FAILED(stat))
  280.             DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  281.     }
  282.  
  283.     switch(parameter.Description.Class)
  284.     {
  285.     case D3DXPC_SCALAR:
  286.     case D3DXPC_VECTOR:
  287.     case D3DXPC_MATRIX_ROWS:
  288.     case D3DXPC_MATRIX_COLUMNS:
  289.         {
  290.             DXCC_ASSERT_EXCEPTIONS_BEGIN()
  291.             {
  292.  
  293.                 MFnDoubleArrayData dArrayData;
  294.                 MDoubleArray dArray;
  295.                 MObject oData;
  296.  
  297.                 hr= pEffect->GetFloatArray(parameter.MyHandle(), fArray, 16);
  298.                 if(DXCC_FAILED(hr))
  299.                     DXCC_GOTO_EXIT(e_Exit, TRUE);
  300.  
  301.                 oData= dArrayData.create(&stat);
  302.                 dArray= dArrayData.array();
  303.                 switch(parameter.Description.Class)
  304.                 {
  305.                     case D3DXPC_SCALAR:
  306.                         {
  307.                             dArray.setLength(1);
  308.                             dArray.set(fArray[0], 0);
  309.                         }
  310.                         break;
  311.                     case D3DXPC_VECTOR:
  312.                         {
  313.                             dArray.setLength(4);
  314.                             for(UINT i= 0; i < 4; i++)
  315.                                 dArray.set(fArray[i], i);
  316.                         }
  317.                         break;                
  318.                     case D3DXPC_MATRIX_ROWS:
  319.                     case D3DXPC_MATRIX_COLUMNS:
  320.                         {
  321.                             dArray.setLength(16);
  322.                             for(UINT i= 0; i < 16; i++)
  323.                                 dArray.set(fArray[i], i);
  324.                         }
  325.                         break;    
  326.                 };
  327.  
  328.                 MPlug plugData= depNode.findPlug(LongDataName);
  329.                 if(plugData.isNull())
  330.                 {
  331.                     oParamValue= aParamValue.create(LongDataName, ShortDataName, MFnData::Type::kDoubleArray, MObject::kNullObj, &stat);
  332.                     if (!stat)
  333.                     {
  334.                         stat.perror("Failed to create Parameter Attribute");
  335.                         DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  336.                     }
  337.                     CHECK_MSTATUS( aParamValue.setHidden( true ) );
  338.                     depNode.addAttribute(oParamValue);
  339.                     plugData= depNode.findPlug(LongDataName);
  340.                 }
  341.                 plugData.setValue(oData);
  342.                 Valid= true;
  343.  
  344.  
  345.             }
  346.             DXCC_ASSERT_EXCEPTIONS_END()
  347.         }
  348.         break;
  349.     case D3DXPC_OBJECT:
  350.         switch(parameter.Description.Type)
  351.         {
  352.         case D3DXPT_STRING:
  353.             {
  354.  
  355.                 DXCC_ASSERT_EXCEPTIONS_BEGIN()
  356.                 {
  357.  
  358.                     MFnStringData StringData;
  359.                     MObject oData;
  360.                     LPCSTR pStr= NULL;
  361.         
  362.                     hr= pEffect->GetString(parameter.MyHandle(), &pStr);
  363.                     if(DXCC_FAILED(hr))
  364.                         DXCC_GOTO_EXIT(e_Exit, TRUE);
  365.                     
  366.                     if(!pStr)
  367.                         pStr= "";
  368.  
  369.                     oData= StringData.create(MString(pStr), &stat);
  370.                     if (!stat)
  371.                     {
  372.                         stat.perror("Failed to create StringData");
  373.                         DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  374.                     }
  375.  
  376.                     MPlug plugData= depNode.findPlug(LongDataName);
  377.                     if(plugData.isNull())
  378.                     {
  379.                         oParamValue= aParamValue.create(LongDataName, ShortDataName, MFnData::Type::kString, MObject::kNullObj, &stat);
  380.                         if (!stat)
  381.                         {
  382.                             stat.perror("Failed to create Parameter Attribute");
  383.                             DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  384.                         }
  385.                         CHECK_MSTATUS( aParamValue.setHidden( true ) );
  386.                         depNode.addAttribute(oParamValue);
  387.                         plugData= depNode.findPlug(LongDataName);
  388.                     }
  389.                     plugData.setValue(oData);
  390.                     Valid= true;
  391.  
  392.                 }
  393.                 DXCC_ASSERT_EXCEPTIONS_END()
  394.  
  395.             }
  396.             break;
  397.         case D3DXPT_TEXTURE:
  398.         case D3DXPT_TEXTURE1D:
  399.         case D3DXPT_TEXTURE2D:
  400.         case D3DXPT_TEXTURE3D:
  401.         case D3DXPT_TEXTURECUBE:
  402.             {
  403.                 DXCC_ASSERT_EXCEPTIONS_BEGIN()
  404.                 {
  405.  
  406.                     MFnStringData StringData;
  407.                     MObject oData;
  408.                     LPDXCCRESOURCE pRes= NULL;
  409.                     LPDIRECT3DBASETEXTURE9 pTexture= NULL;
  410.  
  411.                     hr= pEffect->GetTexture(parameter.MyHandle(), &pTexture);
  412.                     if(DXCC_FAILED(hr))
  413.                         DXCC_GOTO_EXIT(e_Exit, TRUE);
  414.                     
  415.                     if(pTexture 
  416.                         && DXCC_SUCCEEDED(pManager->FindResourceByPointer(pTexture, NULL, &pRes)))
  417.                     {
  418.                         MPlug plugData= depNode.findPlug(LongDataName);
  419.                         LPCSTR pStr= pRes->GetResourcePath();
  420.  
  421.                         if(!pStr)
  422.                             pStr= "";
  423.  
  424.                         oData= StringData.create(MString(pStr), &stat);
  425.                         if (!stat)
  426.                         {
  427.                             stat.perror("Failed to create StringData");
  428.                             DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  429.                         }
  430.  
  431.                         if(plugData.isNull())
  432.                         {
  433.                             oParamValue= aParamValue.create(LongDataName, ShortDataName, MFnData::Type::kString, MObject::kNullObj, &stat);
  434.                             if (!stat)
  435.                             {
  436.                                 stat.perror("Failed to create Parameter Attribute");
  437.                                 DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  438.                             }
  439.                             CHECK_MSTATUS( aParamValue.setHidden( true ) );
  440.                             depNode.addAttribute(oParamValue);
  441.                             plugData= depNode.findPlug(LongDataName);
  442.                         }
  443.                         plugData.setValue(oData);
  444.                         Valid= true;
  445.                     }
  446.                 }
  447.                 DXCC_ASSERT_EXCEPTIONS_END()
  448.             }
  449.             break;
  450.         default:
  451.             break;
  452.         };
  453.         break;
  454.     default:
  455.         break;
  456.     };
  457.  
  458.  
  459.     if(Valid)
  460.     {
  461.         plugName.setValue(parameter.MyName());
  462.         iParameter++;
  463.     }
  464.  
  465.  
  466.     DXCC_ASSERT_EXCEPTIONS_END()
  467.  
  468. e_Exit:    
  469.  
  470.  
  471.     return hr;
  472. }
  473.  
  474. bool 
  475. DAGIsVisible(
  476.     MDagPath& dagPath, 
  477.     MStatus* status)
  478. {
  479.     bool result= true;
  480.     MDagPath path= dagPath;
  481.     MFnDagNode dagNode(path);
  482.  
  483.     if(path.node().hasFn(MFn::kManipulator3D))
  484.         return FALSE;
  485.  
  486.     do
  487.     {
  488.         if( !NodeIsVisible( path.node(), status))
  489.             return false;
  490.     } while( path.pop());
  491.  
  492.     return true;
  493.  
  494.  
  495.     return result;
  496. }
  497.  
  498. bool 
  499. NodeIsVisible(
  500.     MObject& node,
  501.     MStatus* status)
  502. {
  503.     HRESULT    hr= S_OK;
  504.     MStatus TempStatus;
  505.  
  506.     if(!status)
  507.         status= &TempStatus;
  508.     
  509.         
  510.     MFnDagNode DagNode(node); 
  511.  
  512.     bool    bIsVisible= false;
  513.  
  514.     bool    bPlugVisibility= true, 
  515.             bPlugLodVisibility= true, 
  516.             bPlugOverrideEnabled= false, 
  517.             bPlugOverrideVisibility= true,
  518.             bPlugIntermediate= false,
  519.             bPlugUnderworld= false;
  520.  
  521.     MPlug    mpVisibility,
  522.             mpLodVisibility,
  523.             mpOverrideEnabled, 
  524.             mpOverrideVisibility;
  525.             //mpIntermediate;
  526.  
  527.     //VISIBILITY
  528.     mpVisibility = DagNode.findPlug("visibility", status); // intermediateObject //template (these too?)
  529.     if(!*status)
  530.         DXCC_STATUS_EXIT(*status, MS::kFailure, e_Exit, FALSE);
  531.  
  532.     *status = mpVisibility.getValue(bPlugVisibility);
  533.     if(!*status)
  534.         DXCC_STATUS_EXIT(*status, MS::kFailure, e_Exit, FALSE);
  535.  
  536.     //LOD VISIBILITY
  537.     mpLodVisibility = DagNode.findPlug("lodVisibility", status);
  538.     if(!*status)
  539.         DXCC_STATUS_EXIT(*status, MS::kFailure, e_Exit, FALSE);
  540.  
  541.     *status = mpLodVisibility.getValue(bPlugLodVisibility);
  542.     if(!*status)
  543.         DXCC_STATUS_EXIT(*status, MS::kFailure, e_Exit, FALSE);
  544.  
  545.     //Intermediate Object
  546.     //mpIntermediate = DagNode.findPlug("intermediateObject", status);
  547.     //if(!*status)
  548.     //    DXCC_STATUS_EXIT(*status, MS::kFailure, e_Exit, FALSE);
  549.  
  550.     //*status = mpIntermediate.getValue(bPlugIntermediate);
  551.     //if(!*status)
  552.     //    DXCC_STATUS_EXIT(*status, MS::kFailure, e_Exit, FALSE);
  553.  
  554.     bPlugIntermediate= DagNode.isIntermediateObject();
  555.     bPlugUnderworld= DagNode.inUnderWorld();
  556.  
  557.     //OVERRIDE ENABLED
  558.     mpOverrideEnabled = DagNode.findPlug("overrideEnabled", status);
  559.     if(!*status)
  560.         DXCC_STATUS_EXIT(*status, MS::kFailure, e_Exit, FALSE);
  561.  
  562.     *status = mpOverrideEnabled.getValue(bPlugOverrideEnabled);
  563.     if(!*status)
  564.         DXCC_STATUS_EXIT(*status, MS::kFailure, e_Exit, FALSE);
  565.  
  566.     //OVERRIDE VISIBILITY
  567.     mpOverrideVisibility = DagNode.findPlug("overrideVisibility", status);
  568.     if(!*status)
  569.         DXCC_STATUS_EXIT(*status, MS::kFailure, e_Exit, FALSE);
  570.  
  571.     *status = mpOverrideVisibility.getValue(bPlugOverrideVisibility);
  572.     if(!*status)
  573.         DXCC_STATUS_EXIT(*status, MS::kFailure, e_Exit, FALSE);
  574.  
  575.     bIsVisible= bPlugVisibility
  576.         && bPlugLodVisibility 
  577.         && !bPlugIntermediate
  578.         && !bPlugUnderworld 
  579.         && !(bPlugOverrideEnabled && !bPlugOverrideVisibility);
  580.  
  581. e_Exit:
  582.  
  583.     return bIsVisible;    
  584. };
  585.  
  586. UINT MayaGetFPS()
  587. {
  588.     UINT nFPS;    // num frames per second
  589.  
  590.     // calculate the frames per second
  591.     switch(MTime::uiUnit()) 
  592.     {
  593.         case MTime::kSeconds:        // 1 fps
  594.             nFPS = 1;
  595.             break;
  596.         case MTime::kMilliseconds:    // 1000 fps
  597.             nFPS = 1000;
  598.             break;
  599.         case MTime::kGames:            // 15 fps
  600.             nFPS = 15;
  601.             break;
  602.         case MTime::kFilm:            // 24 fps
  603.             nFPS = 24;
  604.             break;
  605.         case MTime::kPALFrame:        // 25 fps
  606.             nFPS = 25;
  607.             break;
  608.         case MTime::kNTSCFrame:        // 30 fps
  609.             nFPS = 30;
  610.             break;
  611.         case MTime::kShowScan:        // 48 fps
  612.             nFPS = 48;
  613.             break;
  614.         case MTime::kPALField:        // 50 fps
  615.             nFPS = 50;
  616.             break;
  617.         case MTime::kNTSCField:        // 60 fps
  618.             nFPS = 60;
  619.             break;
  620.         default:
  621.             nFPS = 1;
  622.             break;
  623.     };
  624.  
  625.     return nFPS;
  626. }
  627.  
  628. void ConvertLocalMatrix(D3DXMATRIX& ToD3D, const MFloatMatrix& FromMaya)
  629. {
  630.     for (UINT i = 0; i < 4; i++)
  631.     {
  632.         for (UINT j = 0; j < 4; j++)
  633.         {
  634.             ToD3D(i, j)= (FLOAT)FromMaya(i, j);
  635.         }
  636.     }
  637. }
  638.  
  639. void ConvertLocalMatrix(D3DXMATRIX& ToD3D, const MMatrix& FromMaya)
  640. {
  641.     MFloatMatrix FromMayaFloat(FromMaya.matrix);
  642.     ConvertLocalMatrix(ToD3D, FromMayaFloat);
  643. }
  644.  
  645. void ConvertWorldMatrix(D3DXMATRIX& ToD3D, const MFloatMatrix& FromMaya)
  646. {
  647.     D3DXMATRIX Local;
  648.     ConvertLocalMatrix(Local, FromMaya);
  649.  
  650.     D3DXMATRIX RtoL;
  651.     D3DXMatrixScaling(&RtoL, 1.0f, 1.0f, -1.0f);
  652.     D3DXMatrixMultiply(&ToD3D, &Local, &RtoL);
  653. }
  654.  
  655. void ConvertWorldMatrix(D3DXMATRIX& ToD3D, const MMatrix& FromMaya)
  656. {
  657.     MFloatMatrix FromMayaFloat(FromMaya.matrix);
  658.     ConvertWorldMatrix(ToD3D, FromMayaFloat);
  659. }
  660.  
  661. bool DCCTagContainer::Add(MObject& objAllPathsTo )
  662. {
  663.     MDagPathArray PathArray;
  664.  
  665.     if(objAllPathsTo.isNull())
  666.         return false;
  667.  
  668.     MDagPath::getAllPathsTo(objAllPathsTo, PathArray);
  669.     for(UINT iPath= 0; iPath < PathArray.length(); iPath++)
  670.     {
  671.         Add(PathArray[iPath], NULL, NULL);
  672.     }
  673.  
  674.     return true;
  675. }
  676.  
  677. bool DCCTagContainer::Add(MDagPath& path, UINT *pIndex, DCCTag** ppTag )
  678. {
  679.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  680.  
  681.     if(Find(path, pIndex, ppTag))
  682.         return false;
  683.  
  684.     if(!DAGIsVisible(path, NULL))
  685.         return false;
  686.  
  687.     DCCTag* pTag= new DCCTag(this, path);
  688.     if(!pTag)
  689.         return false;
  690.  
  691.     GlobalArray.push_back(pTag);
  692.  
  693.     MarkAsDirty(Size()-1);
  694.  
  695.  
  696.  
  697.     if(pIndex)
  698.     {
  699.         *pIndex= Size()-1;
  700.     }
  701.  
  702.     if(ppTag)
  703.     {
  704.         *ppTag= pTag;
  705.     }
  706.  
  707.     DXCC_ASSERT_EXCEPTIONS_END()
  708.  
  709.     return true;
  710. }
  711.  
  712. DCCTag::DCCTag(DCCTagContainer* Owner, MDagPath& path)
  713. {
  714.     pContainer= Owner;
  715.     Dirty= false;
  716.     Initialized= false;
  717.     PathCallback= NULL;
  718.     Resource= NULL;
  719.     Interface= NULL;
  720.  
  721.     SetPath(path);
  722.     pContainer->pPreview->AccessManager()->CreateResource(NULL, IID_NULL, true, &Resource);
  723.  
  724.     DXCC_DPFA_REPORT("TAG: %s [%s]",  path.fullPathName ().asChar(), path.node().apiTypeStr());
  725. };
  726.  
  727. DCCTag::~DCCTag()
  728. {
  729.     if(PathCallback != NULL)
  730.         MMessage::removeCallback(PathCallback);
  731.     
  732.     if(Resource)
  733.     {
  734.         if(Interface)
  735.         {
  736.             if(Resource->GetIID() == IID_IDXCCFrame)
  737.             {
  738.                 LPDXCCFRAME pFrame= (LPDXCCFRAME)Interface;
  739.  
  740.                 pFrame->SetParent(NULL);
  741.  
  742.                 while(pFrame->NumChildren() > 0)
  743.                 {
  744.                     pFrame->RemoveChild(pFrame->NumChildren()-1);
  745.                 }
  746.                 
  747.                 while(pFrame->NumMembers() > 0)
  748.                 {
  749.                     pFrame->RemoveMember(pFrame->NumMembers()-1);
  750.                 }
  751.             }
  752.             else if(Resource->GetIID() == IID_IDXCCMesh)
  753.             {
  754.                 LPDXCCMESH pMesh= (LPDXCCMESH)Interface;
  755.  
  756.                 if(pMesh->NumBones() > 0)
  757.                     pMesh->CreateBones(0);
  758.             }
  759.  
  760.             DXCC_RELEASE(Interface);
  761.  
  762.  
  763.  
  764.         }
  765.  
  766.         if(Resource->DetachObject())
  767.         {
  768.             if(pContainer
  769.                 && pContainer->pPreview
  770.                 && pContainer->pPreview->AccessManager())
  771.                 pContainer->pPreview->AccessManager()->RemoveResource(Resource->GetHandle());
  772.         }
  773.  
  774.         DXCC_RELEASE(Resource);
  775.     }
  776.  
  777.  
  778.     
  779.     DXCC_RELEASE(Resource);
  780.     DXCC_RELEASE(Interface);
  781. };
  782.  
  783.  
  784. void DCCTag::SetPath(MDagPath& newPath)
  785. {
  786.     Path.set(newPath);
  787. }
  788.  
  789. MDagPath& DCCTag::GetPath()
  790. {
  791.     if(!Path.isValid())
  792.         Path= MDagPath();
  793.  
  794.     return Path;
  795. }
  796.  
  797. bool DCCTag::IsInitialized()
  798. {
  799.     return (Initialized && IsValid() && Resource && Interface);
  800. }
  801.  
  802. bool DCCTag::IsValid()
  803. {
  804.     return (Path.isValid());
  805. };
  806.  
  807. void DCCTagContainer::EraseInvalidTags()
  808. {
  809.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  810.  
  811.     for(UINT i= 0; 
  812.         i < Size(); 
  813.         i++)
  814.     {
  815.         DCCTag* pTag= NULL;
  816.         Get(i, pTag);
  817.  
  818.         if(!pTag->IsValid())
  819.         {
  820.             Erase(i);
  821.             i--;
  822.         }
  823.     }
  824.  
  825.     DXCC_ASSERT_EXCEPTIONS_END()
  826.  
  827.     return;
  828. }
  829.  
  830.  
  831. bool DCCTagContainer::Get(UINT index, DCCTag* &pTag)
  832. {
  833.     if(index < Size())
  834.     {
  835.         pTag= GlobalArray[index];
  836.         return true;
  837.     }
  838.     else
  839.         return false;
  840. }
  841.  
  842. bool DCCTagContainer::GetFromDirtyList(UINT index, DCCTag* &pTag)
  843. {
  844.     if(index < Size())
  845.     {
  846.         pTag= DirtyArray[index];
  847.         return true;
  848.     }
  849.     else
  850.         return false;
  851. }
  852.  
  853. UINT DCCTagContainer::SizeFromDirtyList()
  854. {
  855.     return (UINT)DirtyArray.size();
  856. }
  857.  
  858. bool DCCTagContainer::FindFromDirtyList(DCCTag* pFind, UINT *pDirtyListIndex)
  859. {
  860.     for(UINT i= 0; 
  861.         i < SizeFromDirtyList(); 
  862.         i++)
  863.     {
  864.         DCCTag* pTag= NULL;
  865.         GetFromDirtyList(i, pTag);
  866.  
  867.         if(pTag == pFind)
  868.         {
  869.             *pDirtyListIndex= i;
  870.             return true;
  871.         }
  872.     }
  873.  
  874.     return false;
  875. }
  876.  
  877. bool DCCTagContainer::Find(DCCTag* pFind, UINT *pIndex)
  878. {
  879.     for(UINT i= 0; 
  880.         i < Size(); 
  881.         i++)
  882.     {
  883.         DCCTag* pTag= NULL;
  884.         Get(i, pTag);
  885.  
  886.         if(pTag == pFind)
  887.         {
  888.             *pIndex= i;
  889.             return true;
  890.         }
  891.     }
  892.  
  893.     return false;
  894. }
  895.  
  896. bool DCCTagContainer::Find(MDagPath& path, UINT *pIndex, DCCTag** ppTag)
  897. {
  898.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  899.  
  900.     for(UINT i= 0; 
  901.         i < Size(); 
  902.         i++)
  903.     {
  904.         DCCTag* pTag= NULL;
  905.         Get(i, pTag);
  906.  
  907.         if(pTag->GetPath() == path)
  908.         {
  909.             if(pIndex)
  910.                 *pIndex= i;
  911.             if(ppTag)
  912.                 *ppTag= pTag;
  913.  
  914.             return true;
  915.         }
  916.     }
  917.  
  918.     DXCC_ASSERT_EXCEPTIONS_END()
  919.  
  920.     return false;
  921. }
  922.  
  923.  
  924. bool DCCTagContainer::FindFromDirtyList(MDagPath& path, UINT *pIndex, DCCTag** ppTag)
  925. {
  926.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  927.  
  928.     for(UINT i= 0; 
  929.         i < SizeFromDirtyList(); 
  930.         i++)
  931.     {
  932.         DCCTag* pTag= NULL;
  933.         GetFromDirtyList(i, pTag);
  934.  
  935.         if(pTag->GetPath() == path)
  936.         {
  937.             if(pIndex)
  938.                 *pIndex= i;
  939.             if(ppTag)
  940.                 *ppTag= pTag;
  941.  
  942.             return true;
  943.         }
  944.     }
  945.  
  946.     DXCC_ASSERT_EXCEPTIONS_END()
  947.  
  948.     return false;
  949. }
  950.  
  951.  
  952. UINT DCCTagContainer::Size()
  953. {
  954.     return (UINT)GlobalArray.size();
  955. }
  956.  
  957.  
  958. void DCCTagContainer::EraseAll()
  959. {
  960.     if(GlobalArray.size() > 0)
  961.     {
  962.         for(UINT i= 0; i < GlobalArray.size(); i++)
  963.         {
  964.             DCCTag* Element= GlobalArray[i];
  965.             delete Element;
  966.         }
  967.         GlobalArray.clear();
  968.     }
  969.     DirtyArray.clear();
  970. }
  971.  
  972. bool DCCTagContainer::Erase_SLOW(DCCTag* tag)
  973. {
  974.     UINT i= (UINT)-1;
  975.     if(Find(NULL, &i))
  976.     {
  977.         return Erase(i);
  978.     }
  979.     return false;
  980. }
  981.  
  982. bool DCCTagContainer::Erase(UINT index)
  983. {
  984.     if(index < GlobalArray.size())
  985.     {
  986.         DCCTag* &Element= GlobalArray[index];
  987.  
  988.         MarkAsClean_SLOW(Element);
  989.  
  990.         delete Element;
  991.  
  992.         GlobalArray.erase(GlobalArray.begin()+index);
  993.  
  994.         return true;
  995.     }
  996.     return false;
  997. }
  998.  
  999. HRESULT    
  1000. CMayaPreviewPipeline::Scene_Export(
  1001.             const char* file,        // save file object
  1002.             const char* options,    // options string
  1003.             MPxFileTranslator::FileAccessMode mode)
  1004. {
  1005.      HRESULT hr = S_OK;
  1006.     MStatus stat = MS::kSuccess;
  1007.     CPipelineLock SceneLock;
  1008.  
  1009.     SceneWriteLock(true, SceneLock);
  1010.  
  1011.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  1012.  
  1013.     DXCC_DPF(TEXT("Maya XFile Exporter"));
  1014.     DXCC_DPF(TEXT("Copyright (C) 1998-2000 Microsoft Corporation. All Rights Reserved."));
  1015.     DXCC_DPFA("Exporting to \"%s\"...", file);
  1016.  
  1017. #ifdef _XBOX_
  1018.     Scene_Deregister();
  1019.     Scene_Register();
  1020. #endif
  1021.  
  1022.     hr= DXCCSaveScene(
  1023.             file, 
  1024.             D3DXF_FILEFORMAT_TEXT,//D3DXF_FILEFORMAT_BINARY,//
  1025.             AccessManager(), 
  1026.             AccessRoot(), 
  1027.             NULL, 
  1028.             NULL, 
  1029.             NULL);
  1030.     if (DXCC_FAILED(hr))
  1031.         DXCC_GOTO_EXIT(e_Exit, TRUE);
  1032.  
  1033.     DXCC_ASSERT_EXCEPTIONS_END()
  1034.  
  1035. e_Exit:
  1036.  
  1037.     SceneWriteUnlock(SceneLock);
  1038.  
  1039.     return hr;
  1040. }
  1041.  
  1042. //HRESULT    
  1043. //CMayaPreviewPipeline::Export_Options(
  1044. //            const char* file,        // save file object
  1045. //            const char* options,    // options string
  1046. //            MPxFileTranslator::FileAccessMode mode)
  1047. //{
  1048. //        //OPTIONS INITIALIZE
  1049. //        //Options.Hierarchy= TRUE;
  1050. //        //Options.HierarchyCentered= FALSE;
  1051. //        //Options.HierarchyScale.x= 1.0f;
  1052. //        //Options.HierarchyScale.y= 1.0f;
  1053. //        //Options.HierarchyScale.z= 1.0f;
  1054. //
  1055. //        //Options.Mesh= TRUE;
  1056. //        //Options.MeshSkinned= TRUE;
  1057. //
  1058. //        //Options.Material= TRUE;
  1059. //        //Options.MaterialFX= TRUE; 
  1060. //        //Options.MaterialUnqualifyPath= FALSE; 
  1061. //
  1062. //        //Options.Animation= TRUE;
  1063. //        //Options.AnimationController= NULL;
  1064. //        //strcpy(Options.AnimationName, "default");
  1065. //        //Options.AnimationKeysOnly= FALSE;
  1066. //        //Options.AnimationPlaybackType= D3DXPLAY_ONCE;
  1067. //        //Options.AnimationPlayFPS= Options.AnimationSampleFPS= MayaGetFPS();
  1068. //        //Options.AnimationStartTime= MAnimControl::minTime().value(); 
  1069. //        //Options.AnimationEndTime= (DOUBLE)MAnimControl::maxTime().value();
  1070. //
  1071. //        //Options.OutputFormat= D3DXF_FILEFORMAT_BINARY;//D3DXF_FILEFORMAT_TEXT;//
  1072. //        //strcpy(Options.OutputSaveAs, file);
  1073. //    }//END//OPTIONS INITIALIZE
  1074. //
  1075. //
  1076. //
  1077. //    //hr= DXCCShowSaveDialog(&Options);
  1078. //    //if (DXCC_FAILED(hr))
  1079. //    //    DXCC_GOTO_EXIT(e_Exit, TRUE);
  1080. //}
  1081.  
  1082.  
  1083.  
  1084.  
  1085. void CMayaPreviewPipeline::Scene_Update(bool bForceUpdate)
  1086. {
  1087.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  1088.  
  1089.  
  1090.     DXCCTimeStamp TimeStamp;
  1091.     CPipelineLock SceneLock;    
  1092.  
  1093.     if(!bForceUpdate)
  1094.     {
  1095.         if(TimeStamp.RoughlyEqual(TagContainer.TimeStamp))
  1096.             return;
  1097.     }
  1098.  
  1099.     //always update the camera...when enough time has passed
  1100.     Synchronize_PerspectiveCamera();
  1101.  
  1102.     if(    TagContainer.SizeFromDirtyList() > 0 || 
  1103.         DirtyShaders.size() > 0)
  1104.     {
  1105.         SceneWriteLock(true, SceneLock);
  1106.         MGlobal::displayInfo("DXCC BEGINNING TO COPY SCENE");
  1107.  
  1108.         //update materials since dirty materials will make dirty meshes
  1109.         Scene_Update_Materials(bForceUpdate, TimeStamp);
  1110.  
  1111.         //remove any invisible nodes which are dirty
  1112.         Scene_Update_Visibility(bForceUpdate, TimeStamp);
  1113.  
  1114.         //update the frames since meshes rely on them
  1115.         Scene_Update_Tags(bForceUpdate, TimeStamp, MFn::kTransform);
  1116.  
  1117.         //update meshes 
  1118.         Scene_Update_Tags(bForceUpdate, TimeStamp, MFn::kMesh);
  1119.  
  1120.         MGlobal::displayInfo("DXCC FINISHED COPYING SCENE");
  1121.         SceneWriteUnlock(SceneLock);
  1122.     }
  1123.  
  1124.     //always update the timeso that we know it's been long enough 
  1125.     //between updates ....NOTE this is at the end to garantee usable time 
  1126.     //rather than maintaining interactive rates
  1127.     //TODO: track and avg time of updates and and throttle the values in RoughlyEquals 
  1128.     //instead to smooth out interaction.
  1129.     TimeStamp.AcquireTime();
  1130.  
  1131.     DXCC_ASSERT_EXCEPTIONS_END()
  1132.  
  1133.     return;
  1134. }
  1135.  
  1136.  
  1137. void CMayaPreviewPipeline::Scene_Update_Animation()
  1138. {
  1139.     HRESULT hr= S_OK;
  1140.  
  1141.     for(UINT iDirty= 0; 
  1142.         iDirty < TagContainer.Size();
  1143.         iDirty++)
  1144.     {
  1145.         DCCTag* pTag= NULL;
  1146.  
  1147.         if(!TagContainer.Get(iDirty, pTag))
  1148.             continue;
  1149.  
  1150.         //for realtime attempts at tracking animation.//not using this approach
  1151.         //if(pTag->DirtyAnimationFlag)
  1152.         //we're just going to regather everything regardless of being dirty
  1153.         //pTag->DirtyAnimationFlag= false;
  1154.  
  1155.         Frame_GatherAnimation(pTag);//ok if this fails
  1156.  
  1157.     }
  1158.  
  1159. //e_Exit:
  1160.     return;
  1161. }
  1162.  
  1163. void CMayaPreviewPipeline::Scene_Update_Visibility(bool bForceUpdate, DXCCTimeStamp& TimeStamp)
  1164. {
  1165.     HRESULT hr= S_OK;
  1166.     MStatus stat = MS::kSuccess;
  1167.  
  1168.     UINT CleanedCount= 0;
  1169.     UINT DirtyCount= TagContainer.SizeFromDirtyList();
  1170.     for(UINT i= 0; 
  1171.         i < DirtyCount;
  1172.         i++)
  1173.     {
  1174.         DCCTag* pTag= NULL;
  1175.  
  1176.         UINT iDirty= i-CleanedCount;
  1177.  
  1178.         if(!TagContainer.GetFromDirtyList(iDirty, pTag))
  1179.             continue;
  1180.  
  1181.         if(!bForceUpdate)
  1182.         {
  1183.             if(TimeStamp.RoughlyEqual(pTag->TimeStamp))
  1184.                 continue;
  1185.         }
  1186.  
  1187.         if(pTag->IsInitialized())
  1188.         {
  1189.             MDagPath path= pTag->GetPath();
  1190.  
  1191.             if(!DAGIsVisible(path, &stat))
  1192.             {
  1193.                 Tag_Remove(path.node());
  1194.                 CleanedCount++;
  1195.             }
  1196.         }
  1197.     }
  1198. }
  1199.  
  1200. void CMayaPreviewPipeline::Scene_Update_Tags(bool bForceUpdate, DXCCTimeStamp& TimeStamp, MFn::Type type)
  1201. {
  1202.     UINT CleanedCount= 0;
  1203.     UINT DirtyCount= TagContainer.SizeFromDirtyList();
  1204.     for(UINT i= 0; 
  1205.         i < DirtyCount;
  1206.         i++)
  1207.     {
  1208.         DCCTag* pTag= NULL;
  1209.  
  1210.         UINT iDirty= i-CleanedCount;
  1211.  
  1212.         if(!TagContainer.GetFromDirtyList(iDirty, pTag))
  1213.             continue;
  1214.  
  1215.         //skip tags that to recent unless we are forced to do so
  1216.         if(!bForceUpdate)
  1217.         {
  1218.             if(TimeStamp.RoughlyEqual(pTag->TimeStamp))
  1219.                 continue;
  1220.         }
  1221.     
  1222.         //skip tags that maya throws exception for when i try to initialize
  1223.         if(pTag->CanInitialize())        
  1224.         {
  1225.             bool InitializeMe= !pTag->IsInitialized();
  1226.             MDagPath dagTag= pTag->GetPath();
  1227.  
  1228.             //skip tags that are not of the desired type
  1229.             switch(type)
  1230.             {
  1231.             case MFn::kMesh:
  1232.                 if(!dagTag.hasFn(MFn::kMesh))
  1233.                     continue;
  1234.                 break;
  1235.             case MFn::kTransform:
  1236.                 if(dagTag.hasFn(MFn::kMesh))//in future kShape
  1237.                     continue;
  1238.                 break;
  1239.             };
  1240.             
  1241.             if(InitializeMe)
  1242.                 DXCC_DPFA_REPORT("INITIALIZE TAG: %s", dagTag.fullPathName().asChar());
  1243.  
  1244.  
  1245.             Synchronize_Tag(pTag);
  1246.  
  1247.             //parent because we arent in the tree yet!
  1248.             //rechild because we cant garantee the ordering from maya.
  1249.             //EX FOR RECHILD: the child may be added and the parent may not exist at that time
  1250.             //so it gets added the the global parent.
  1251.             //then the parent gets added and if you dont rechild the hierarchy is wrong.
  1252.             if(InitializeMe)
  1253.             {
  1254.                 MDagPath dagParent= dagTag;
  1255.                 dagParent.pop();
  1256.  
  1257.                 for(UINT iChild= 0; iChild < dagTag.childCount(); iChild++)
  1258.                 {
  1259.                     MDagPath dagChild= dagTag;
  1260.                     dagChild.push(dagTag.child(iChild));
  1261.  
  1262.                     Tag_Reparent(MDagMessage::DagMessage::kParentAdded,dagChild, dagTag, false);
  1263.                 }
  1264.                 Tag_Reparent(MDagMessage::DagMessage::kParentAdded,dagTag, dagParent, false);
  1265.  
  1266.                 pTag->SetInitialized(true);
  1267.             }
  1268.  
  1269.             //We cleaned the tag!
  1270.             TagContainer.MarkAsClean(iDirty);
  1271.  
  1272.             CleanedCount++;
  1273.         }
  1274.     }
  1275. }
  1276.  
  1277. void CMayaPreviewPipeline::Scene_Update_Materials(bool bForceUpdate, DXCCTimeStamp& TimeStamp)
  1278. {
  1279.     if(DirtyShaders.size() > 0)
  1280.     {
  1281.  
  1282.         for(UINT iDirty = 0; iDirty < DirtyShaders.size(); iDirty++)
  1283.         {
  1284.             //materials should respond quickly so we are not throttling them by RoughlyEquals
  1285.  
  1286.             Synchronize_Material(DirtyShaders[iDirty]);
  1287.         }
  1288.         DirtyShaders.clear();
  1289.     }
  1290. }
  1291.  
  1292. bool DCCTag::CanInitialize()
  1293. {
  1294.     HRESULT hr= S_OK;
  1295.     MStatus stat= MS::kSuccess;
  1296.     MDagPath TagDP= GetPath();
  1297.     MFnDependencyNode depNode(TagDP.node());
  1298.  
  1299.     if(TagDP.node().hasFn(MFn::kMesh))
  1300.     {
  1301.         try
  1302.         {
  1303.             MFnMesh mesh(TagDP.node(), &stat);
  1304.             if(MAYA_FAILED(stat))//don't place hooks until this stops 'passing'
  1305.                 return false;
  1306.         }
  1307.         catch (...)
  1308.         {
  1309.             return false;
  1310.         }
  1311.     }
  1312.     else if(TagDP.node().hasFn(MFn::kTransform))
  1313.     {
  1314.         try
  1315.         {
  1316.             MFnTransform transform(TagDP.node(), &stat);
  1317.             if(MAYA_FAILED(stat))//don't place hooks until this stops 'passing'
  1318.                 return false;
  1319.         }
  1320.         catch (...)
  1321.         {
  1322.             return false;
  1323.         }
  1324.     }
  1325.  
  1326.     return true;
  1327. }
  1328.  
  1329.  
  1330. bool DCCTag::SetInitialized(bool bInitializeNow)
  1331. {
  1332.     HRESULT hr= S_OK;
  1333.     MStatus stat= MS::kSuccess;
  1334.  
  1335.     if(IsInitialized())
  1336.     {
  1337.         if(bInitializeNow)
  1338.         {
  1339.             return true;
  1340.         }
  1341.         else
  1342.         {
  1343.             MMessage::removeCallback(PathCallback);
  1344.             PathCallback=0;
  1345.             Initialized= false;
  1346.             return false;
  1347.         }
  1348.     }
  1349.     else
  1350.     {
  1351.         if(!bInitializeNow)
  1352.         {
  1353.             return true;
  1354.         }
  1355.         else if( CanInitialize() )
  1356.         {
  1357.             Initialized= true;
  1358.  
  1359.             return true;
  1360.         }
  1361.     }
  1362.  
  1363.     return false;
  1364. }
  1365.  
  1366. DXCCTimeStamp::DXCCTimeStamp() 
  1367. {
  1368.     AcquireTime();
  1369. } 
  1370.  
  1371. void 
  1372. DXCCTimeStamp::AcquireTime()
  1373. {
  1374.     _ftime(&Coarse);
  1375.     Fine= clock();
  1376. }
  1377.  
  1378. bool 
  1379. DXCCTimeStamp::RoughlyEqual(DXCCTimeStamp &test)
  1380. {
  1381.     if(this->Coarse.time == test.Coarse.time)
  1382.     {
  1383.         float micro= test.Coarse.millitm - this->Coarse.millitm;
  1384.         if(micro <= DX_UPDATE_FREQUENCY)
  1385.         {
  1386.             return true;
  1387.         }
  1388.     }
  1389.     return false;
  1390. }
  1391.  
  1392.  
  1393. void CMayaPreviewPipeline::UI_SetPreviewState(bool bPreview)
  1394. {
  1395.     MStatus stat= MS::kSuccess;
  1396.     if(bPreview == false && CallbackId_PreviewArray.length() > 0)//NOT PREVIEWING
  1397.     {
  1398.         MMessage::removeCallbacks(CallbackId_PreviewArray);     
  1399.         CallbackId_PreviewArray.clear();
  1400.     }
  1401.     else if(bPreview == true && CallbackId_PreviewArray.length() == 0)//PREVIEWING
  1402.     {
  1403.         CallbackId_PreviewArray.append(MSceneMessage::addCallback( MSceneMessage::Message::kBeforeOpen, CMayaPreviewPipeline::Callback_ScenePreload, NULL, &stat));
  1404.         CallbackId_PreviewArray.append(MSceneMessage::addCallback( MSceneMessage::Message::kSceneUpdate, CMayaPreviewPipeline::Callback_ScenePostload, NULL, &stat));
  1405.         CallbackId_PreviewArray.append(MSceneMessage::addCallback( MSceneMessage::Message::kMayaInitialized, CMayaPreviewPipeline::Callback_ScenePostload, NULL, &stat));
  1406.         
  1407.         CallbackId_PreviewArray.append(MSceneMessage::addCallback( MSceneMessage::Message::kBeforeSave, CMayaPreviewPipeline::Callback_SceneSave, NULL, &stat));
  1408.         
  1409.         CallbackId_PreviewArray.append(MEventMessage::addEventCallback("idle", CMayaPreviewPipeline::Callback_SceneIdle, NULL, &stat));
  1410.         
  1411.         CallbackId_PreviewArray.append(MDGMessage::addNodeAddedCallback( CMayaPreviewPipeline::Callback_NodeAdded, kDefaultNodeType, NULL, &stat)); 
  1412.         CallbackId_PreviewArray.append(MDGMessage::addNodeRemovedCallback( CMayaPreviewPipeline::Callback_NodeRemoved, kDefaultNodeType, NULL, &stat)); 
  1413.         //CallbackId_PreviewArray.append(MAnimMessage::addAnimCurveEditedCallback( CMayaPreviewPipeline::Callback_AnimationEdit, NULL, &stat)); 
  1414.     }
  1415. }
  1416.  
  1417. bool CMayaPreviewPipeline::UI_GetPreviewState()
  1418. {    
  1419.     int state= 0;
  1420.     MGlobal::executeCommand ("DirectX_GetPreviewState()",  state);
  1421.     //MGlobal::executeCommand ("menuItem -q -checkBox  $g_dxPreviewToggle;",  state);
  1422.  
  1423.     return (bool)(state==0?false:true);
  1424. }
  1425.  
  1426. bool CMayaPreviewPipeline::UI_GetSkinState()
  1427. {    
  1428.     int state= 0;
  1429.     MGlobal::executeCommand ("DirectX_GetSkinState()",  state);
  1430.     //MGlobal::executeCommand ("menuItem -q -checkBox  $g_dxSkinToggle;",  state);
  1431.  
  1432.     return (bool)(state==0?false:true);
  1433. }
  1434.  
  1435.  
  1436. HRESULT CMayaPreviewPipeline::Create()
  1437. {
  1438.     HRESULT hr= S_OK;
  1439.     MStatus stat= MS::kSuccess;
  1440.     MItDag FindRoot;
  1441.  
  1442.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  1443.     
  1444.     hr= CPipeline::Create();
  1445.     if(DXCC_FAILED(hr))
  1446.         DXCC_GOTO_EXIT(e_Exit, TRUE);
  1447.  
  1448.     //-----------------------INITIALIZATION ------------------------//
  1449.     FindRoot.getPath(MayaRoot);
  1450.  
  1451.     DxRoot.Interface= AccessRoot();
  1452.     DxRoot.Interface->AddRef();
  1453.  
  1454.     (*(LPD3DXMATRIX)(void*)AccessRoot()->GetLocalMatrix())(2,2)= -1.0f;
  1455.     (*(LPD3DXMATRIX)(void*)AccessRoot()->GetWorldMatrix())(2,2)= -1.0f;
  1456.  
  1457.  
  1458.     hr= AccessManager()->FindResourceByPointer(DxRoot.Interface, NULL, &DxRoot.Resource );
  1459.     if(DXCC_FAILED(hr))
  1460.         DXCC_GOTO_EXIT(e_Exit, TRUE);
  1461.  
  1462.     DeviceCreatedEvent= CreateEventA(NULL, FALSE, FALSE, "DXCCPipeline_DeviceCreated");
  1463.     InitializeCriticalSection(&DeviceAndViewerSection);
  1464.  
  1465.  
  1466.  
  1467.     g_Engine.Create(this);
  1468.     SetEngine(&g_Engine);
  1469.  
  1470.     DXCC_ASSERT_EXCEPTIONS_END()
  1471.  
  1472. e_Exit:
  1473.     return hr;
  1474. }
  1475.  
  1476. void CMayaPreviewPipeline::Scene_Register()
  1477. {
  1478.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  1479.  
  1480.     CPipelineLock SceneLock;
  1481.     SceneWriteLock(true, SceneLock);
  1482.  
  1483.     MStatus stat= MS::kSuccess;
  1484.  
  1485.     UI_SetPreviewState(UI_GetPreviewState());
  1486.  
  1487.     for(MItDependencyNodes iter; !iter.isDone(); iter.next())
  1488.     {
  1489.         Tag_Add( iter.item() );
  1490.     }
  1491.  
  1492.     Scene_Update(true);
  1493.  
  1494.     SceneWriteUnlock(SceneLock);
  1495.     DXCC_ASSERT_EXCEPTIONS_END()
  1496. }
  1497.  
  1498. HRESULT CMayaPreviewPipeline::Destroy()
  1499. {
  1500.     CPipelineLock SceneLock;
  1501.     SceneWriteLock(true, SceneLock);
  1502.  
  1503.     Scene_Deregister();
  1504.     
  1505.     CPipeline::Destroy();
  1506.  
  1507.     g_Engine.Destroy();
  1508.  
  1509.  
  1510.  
  1511.     MMessage::removeCallback( CallbackId_Exiting);
  1512.     CallbackId_Exiting=0;
  1513.     MMessage::removeCallback( CallbackId_AfterOpen);
  1514.     CallbackId_AfterOpen=0;
  1515.     MMessage::removeCallbacks(CallbackId_PreviewArray);
  1516.     MMessage::removeCallbacks(CallbackId_NodeArray);
  1517.  
  1518.  
  1519.     CloseHandle(DeviceCreatedEvent);
  1520.     DeviceCreatedEvent= NULL;
  1521.     DeleteCriticalSection(&DeviceAndViewerSection);
  1522.     //DeviceAndViewerSection= NULL;
  1523.  
  1524.     SceneWriteUnlock(SceneLock);
  1525.  
  1526.     return S_OK;
  1527. }
  1528.  
  1529. void CMayaPreviewPipeline::Scene_Deregister()
  1530. {
  1531.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  1532.     LPDXCCFRAME pRoot= NULL;
  1533.     CPipelineLock SceneLock;
  1534.     SceneWriteLock(true, SceneLock);
  1535.  
  1536.     UI_SetPreviewState(false);
  1537.  
  1538.     pRoot= AccessRoot();
  1539.     pRoot->AddRef();
  1540.  
  1541.     while(pRoot->NumChildren() > 0)
  1542.     {
  1543.         pRoot->RemoveChild(0);
  1544.     }
  1545.  
  1546.     while(pRoot->NumMembers() > 0)
  1547.     {
  1548.         pRoot->RemoveMember(0);
  1549.     }
  1550.  
  1551.     DXCC_RELEASE(pRoot);
  1552.  
  1553.     TagContainer.EraseAll();
  1554.  
  1555.     MMessage::removeCallbacks(CallbackId_NodeArray);
  1556.  
  1557.     SceneWriteUnlock(SceneLock);
  1558.     DXCC_ASSERT_EXCEPTIONS_END()
  1559. }
  1560.  
  1561.  
  1562.  
  1563. HRESULT CMayaPreviewPipeline::Tag_Remove( MObject & node )
  1564. {
  1565.     HRESULT hr= S_OK;
  1566.     MStatus stat = MS::kSuccess;
  1567.  
  1568.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  1569.  
  1570.     MObject oAttr;
  1571.     int cid;    
  1572.     MDagPathArray PathArray;
  1573.     MFnDependencyNode depNode(node);
  1574.  
  1575.     MPlug plugNameCallback= depNode.findPlug(DX_LONG_NAME_CALLBACKID);
  1576.     if(!plugNameCallback.isNull())
  1577.     {
  1578.         stat= plugNameCallback.getValue(cid);
  1579.         MMessage::removeCallback((MCallbackId)cid);
  1580.     }
  1581.  
  1582.     MPlug plugAttributeCallback= depNode.findPlug(DX_LONG_ATTRIB_CALLBACKID);
  1583.     if(!plugAttributeCallback.isNull())
  1584.     {
  1585.         stat= plugAttributeCallback.getValue(cid);
  1586.         MMessage::removeCallback((MCallbackId)cid);
  1587.     }
  1588.  
  1589.     //TagContainer.EraseInvalidTags();
  1590.  
  1591.     stat= MDagPath::getAllPathsTo(node, PathArray);
  1592.     for(UINT iPath= 0; iPath < PathArray.length(); iPath++)
  1593.     {
  1594.         UINT iRemove;
  1595.     
  1596.         MItDag itDag;
  1597.         for (itDag.reset(PathArray[iPath]); !itDag.isDone(); itDag.next())
  1598.         {
  1599.             UINT iRemove;
  1600.             MDagPath leaf;
  1601.             itDag.getPath(leaf);
  1602.  
  1603.             MFnDagNode leafDN(leaf);
  1604.             if(TagContainer.Find(leaf, &iRemove, NULL))
  1605.             {
  1606.                 DXCC_DPFA_REPORT("Erase NODE: %s", leaf.fullPathName().asChar());
  1607.                 if(!TagContainer.Erase(iRemove))
  1608.                     DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);    
  1609.             }
  1610.  
  1611.         }
  1612.     }
  1613.  
  1614.     DXCC_ASSERT_EXCEPTIONS_END()
  1615.  
  1616. e_Exit:
  1617.     return hr;
  1618. }
  1619.  
  1620.  
  1621. HRESULT CMayaPreviewPipeline::Tag_Add( MObject & node )
  1622. {
  1623.     HRESULT hr= S_OK;
  1624.     MStatus stat = MS::kSuccess;
  1625.     MFnNumericAttribute attr;
  1626.     MCallbackId cid;
  1627.     MPlug plugNameCallback;
  1628.     MPlug plugAttributeCallback;
  1629.     const char* typeStr= NULL;
  1630.     const char* nameStr= NULL;
  1631.  
  1632.  
  1633.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  1634.  
  1635.     MFnDependencyNode depNode(node);
  1636.  
  1637.     if(node.hasFn(MFn::kManipulator3D)
  1638.     //|| node.hasFn(MFn::kGroundPlane)
  1639.     || node.hasFn(MFn::kCamera)
  1640.     )
  1641.         return hr;
  1642.  
  1643.  
  1644.     typeStr= node.apiTypeStr();
  1645.     nameStr= depNode.name().asChar();
  1646.  
  1647.     if(node.hasFn(MFn::kDagNode)
  1648.         //||
  1649.         //node.hasFn(MFn::kMesh)|| 
  1650.         //node.hasFn(MFn::kTransform)
  1651.         )
  1652.     {
  1653.         if(TagContainer.Add(node))
  1654.         {
  1655.             cid= MNodeMessage::addNameChangedCallback( node, CMayaPreviewPipeline::Callback_NodeNameChange, NULL, &stat);
  1656.             CallbackId_NodeArray.append(cid);
  1657.             plugNameCallback= depNode.findPlug(DX_LONG_NAME_CALLBACKID);
  1658.             if(plugNameCallback.isNull())
  1659.             {
  1660.                 MObject oAttr= attr.create(DX_LONG_NAME_CALLBACKID, DX_SHORT_NAME_CALLBACKID, MFnNumericData::Type::kInt, 0, &stat);
  1661.                 CHECK_MSTATUS( attr.setHidden( true ) );
  1662.                 CHECK_MSTATUS( attr.setStorable( false ) );
  1663.                 stat= depNode.addAttribute(oAttr, MFnDependencyNode::MAttrClass::kLocalDynamicAttr);
  1664.             }
  1665.             plugNameCallback.setValue((INT)cid);
  1666.  
  1667.  
  1668.             cid= MNodeMessage::addAttributeChangedCallback( node, CMayaPreviewPipeline::Callback_NodeAttributeChanged, NULL, &stat);
  1669.             CallbackId_NodeArray.append(cid);
  1670.             plugAttributeCallback= depNode.findPlug(DX_LONG_ATTRIB_CALLBACKID);
  1671.             if(plugAttributeCallback.isNull())
  1672.             {
  1673.                 MObject oAttr= attr.create(DX_LONG_ATTRIB_CALLBACKID, DX_SHORT_ATTRIB_CALLBACKID, MFnNumericData::Type::kInt, 0, &stat);
  1674.                 CHECK_MSTATUS( attr.setHidden( true ) );
  1675.                 CHECK_MSTATUS( attr.setStorable( false ) );
  1676.                 stat= depNode.addAttribute(oAttr, MFnDependencyNode::MAttrClass::kLocalDynamicAttr);
  1677.             }
  1678.             plugAttributeCallback.setValue((INT)cid);
  1679.         }
  1680.     }
  1681.  
  1682.  
  1683.     DXCC_ASSERT_EXCEPTIONS_END()
  1684.  
  1685. //e_Exit:
  1686.     return hr;
  1687. }
  1688.  
  1689. HRESULT CMayaPreviewPipeline::Tag_Rename( MObject & node)
  1690. {
  1691.     HRESULT hr= S_OK;
  1692.     MStatus stat = MS::kSuccess;
  1693.  
  1694.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  1695.  
  1696.     MFnDependencyNode depNode(node);
  1697.  
  1698.     MDagPathArray PathArray;
  1699.     stat= MDagPath::getAllPathsTo(node, PathArray);
  1700.     for(UINT iPath= 0; iPath < PathArray.length(); iPath++)
  1701.     {
  1702.         DCCTag* tag= NULL;
  1703.         
  1704.         if(TagContainer.Find(PathArray[iPath], NULL, &tag)
  1705.             && tag->Resource != NULL)
  1706.         {
  1707.             DXCC_DPFA_REPORT("NAME: %s",  PathArray[iPath].fullPathName ().asChar());
  1708.             
  1709.             hr= tag->Resource->SetName(MakeNameExportable(tag->GetPath().partialPathName(&stat)).asChar());
  1710.             if(DXCC_FAILED(hr))
  1711.                 DXCC_GOTO_EXIT(e_Exit, TRUE);
  1712.         }
  1713.     }
  1714.  
  1715.     DXCC_ASSERT_EXCEPTIONS_END()
  1716.  
  1717. e_Exit:
  1718.     return hr;
  1719. }
  1720.  
  1721. HRESULT CMayaPreviewPipeline::Tag_Reparent( MDagMessage::DagMessage dagMsg, MDagPath &child, MDagPath &parent, bool bFixInstances)
  1722. {
  1723.     HRESULT hr= S_OK;
  1724.     MStatus stat = MS::kSuccess;
  1725.  
  1726.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  1727.  
  1728.     MFnDependencyNode depNode(child.node());
  1729.  
  1730.     DCCTag* ChildTag=NULL;
  1731.     DCCTag* ParentTag=NULL;
  1732.     char* Msg= "";
  1733.  
  1734.     switch(dagMsg)
  1735.     {
  1736.     case MDagMessage::DagMessage::kParentAdded:
  1737.         Msg="ParentAdded";
  1738.         break;
  1739.     case MDagMessage::DagMessage::kChildAdded:
  1740.         DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);    
  1741.         //Msg="ChildAdded";
  1742.         //break;
  1743.     case MDagMessage::DagMessage::kParentRemoved:
  1744.         Msg="ParentRemoved";
  1745.         break;
  1746.     case MDagMessage::DagMessage::kChildRemoved:
  1747.         DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);    
  1748.         //Msg="ChildRemoved";
  1749.         //break;
  1750.     };
  1751.  
  1752.  
  1753.     if(bFixInstances)
  1754.     {
  1755.         if(dagMsg == MDagMessage::DagMessage::kParentAdded)
  1756.         {
  1757.             MItDag itDag;
  1758.             for (itDag.reset(child, MItDag::kBreadthFirst); !itDag.isDone() && (itDag.depth() <= 1) ; itDag.next())
  1759.             {
  1760.                 MDagPath leaf;
  1761.                 itDag.getPath(leaf);
  1762.                 
  1763.                 if(leaf.isInstanced())
  1764.                 {
  1765.                     TagContainer.Add(leaf, NULL, NULL);//will fail if already exists
  1766.                 }
  1767.             }
  1768.         }
  1769.         else if(dagMsg == MDagMessage::DagMessage::kParentRemoved)
  1770.         {
  1771.             MItDag itDag;
  1772.             for (itDag.reset(child); !itDag.isDone(); itDag.next())
  1773.             {
  1774.                 UINT iRemove;
  1775.                 MDagPath leaf;
  1776.                 itDag.getPath(leaf);
  1777.                 
  1778.                 if(TagContainer.Find(leaf, &iRemove, NULL))
  1779.                 {            
  1780.                     TagContainer.Erase(iRemove);
  1781.                 }
  1782.             }
  1783.         }
  1784.     }
  1785.  
  1786.     if(parent.hasFn(MFn::kWorld))//parent == DxRoot.GetPath())
  1787.         ParentTag= &DxRoot;
  1788.     else if(!TagContainer.Find(parent, NULL, &ParentTag))
  1789.     {
  1790.         const char* parenttype= parent.node().apiTypeStr();
  1791.         return S_OK;
  1792.     }
  1793.  
  1794.     if(child.hasFn(MFn::kWorld))//parent == DxRoot.GetPath())
  1795.         return S_OK;//ChildTag= &DxRoot;
  1796.     else if(!TagContainer.Find(child, NULL, &ChildTag))
  1797.     {
  1798.         const char* childtype= child.node().apiTypeStr();
  1799.         return S_OK;
  1800.     }
  1801.     else if(ChildTag == ParentTag)
  1802.     {
  1803.         const char* parenttype= parent.node().apiTypeStr();
  1804.         const char* childtype= child.node().apiTypeStr();
  1805.         ParentTag= &DxRoot;
  1806.     }
  1807.  
  1808.  
  1809.     if(    ChildTag
  1810.         && ParentTag
  1811.         &&ChildTag->Interface  
  1812.         && ParentTag->Interface)
  1813.     {
  1814.         DXCC_DPFA_REPORT("PARENTING: (%s) %s <==> %s", Msg, parent.fullPathName().asChar(), child.fullPathName().asChar());
  1815.  
  1816.         if( ParentTag->Resource->GetIID() == IID_IDXCCFrame 
  1817.             && ChildTag->Resource->GetIID() == IID_IDXCCFrame)
  1818.         {
  1819.             if(dagMsg == MDagMessage::DagMessage::kParentAdded)
  1820.             {
  1821.                 hr=((LPDXCCFRAME)ChildTag->Interface)->SetParent(((LPDXCCFRAME)ParentTag->Interface));
  1822.                 if(DXCC_FAILED(hr))
  1823.                     DXCC_GOTO_EXIT(e_Exit, TRUE);
  1824.  
  1825.                 TriggerViewerEvents.OnFrameChildAdded((LPDXCCFRAME)ParentTag->Interface, (LPDXCCFRAME)ChildTag->Interface);
  1826.  
  1827.             }
  1828.             else if(dagMsg == MDagMessage::DagMessage::kParentRemoved)
  1829.             {
  1830.                 hr=((LPDXCCFRAME)ChildTag->Interface)->SetParent(NULL);
  1831.                 if(DXCC_FAILED(hr))
  1832.                     DXCC_GOTO_EXIT(e_Exit, TRUE);
  1833.  
  1834.                 TriggerViewerEvents.OnFrameChildRemoved((LPDXCCFRAME)ParentTag->Interface, (LPDXCCFRAME)ChildTag->Interface);
  1835.             }
  1836.         }
  1837.         else if( ParentTag->Resource->GetIID() == IID_IDXCCFrame 
  1838.             && ChildTag->Resource->GetIID() == IID_IDXCCMesh)
  1839.         {
  1840.             if(dagMsg == MDagMessage::DagMessage::kParentAdded )
  1841.             {
  1842.                 hr=((LPDXCCFRAME)ParentTag->Interface)->AddMember((LPDXCCMESH)ChildTag->Interface);
  1843.                 if(DXCC_FAILED(hr))
  1844.                     DXCC_GOTO_EXIT(e_Exit, TRUE);
  1845.  
  1846.                 TriggerViewerEvents.OnFrameMemberAdded((LPDXCCFRAME)ParentTag->Interface, (LPDXCCMESH)ChildTag->Interface);
  1847.             }
  1848.             else if(dagMsg == MDagMessage::DagMessage::kParentRemoved )
  1849.             {
  1850.                 UINT iRemove;
  1851.                 if(DXCC_SUCCEEDED(((LPDXCCFRAME)ParentTag->Interface)->FindMemberByPointer(ChildTag->Interface, &iRemove)))
  1852.                 {
  1853.                     hr=((LPDXCCFRAME)ParentTag->Interface)->RemoveMember(iRemove);
  1854.                     if(DXCC_FAILED(hr))
  1855.                         DXCC_GOTO_EXIT(e_Exit, TRUE);
  1856.                 
  1857.                     TriggerViewerEvents.OnFrameMemberRemoved((LPDXCCFRAME)ParentTag->Interface, (LPDXCCMESH)ChildTag->Interface);
  1858.                 }
  1859.             }
  1860.         }
  1861.     }
  1862.  
  1863.     DXCC_ASSERT_EXCEPTIONS_END()    
  1864. e_Exit:
  1865.     return hr;
  1866. }
  1867.  
  1868. void DPF_DEPNodeAttributeChanged(    MNodeMessage::AttributeMessage msg, 
  1869.                                     MPlug & plug,
  1870.                                     MPlug & otherPlug )
  1871. {
  1872.     DXCC_DPF_HEADER(TEXT("INFO"));
  1873.     DXCC_DPFA_SHORT("ATTRIBUTE: (");
  1874.     if(msg & MNodeMessage::AttributeMessage::kConnectionMade)
  1875.         DXCC_DPFA_SHORT("kConnectionMade|");
  1876.     if(msg & MNodeMessage::AttributeMessage::kConnectionBroken)
  1877.         DXCC_DPFA_SHORT("kConnectionBroken|");
  1878.     if(msg & MNodeMessage::AttributeMessage::kAttributeEval)
  1879.         DXCC_DPFA_SHORT("kAttributeEval|");
  1880.     if(msg & MNodeMessage::AttributeMessage::kAttributeSet)
  1881.         DXCC_DPFA_SHORT("kAttributeSet|");
  1882.     if(msg & MNodeMessage::AttributeMessage::kAttributeLocked)
  1883.         DXCC_DPFA_SHORT("kAttributeLocked|");
  1884.     if(msg & MNodeMessage::AttributeMessage::kAttributeUnlocked)
  1885.         DXCC_DPFA_SHORT("kAttributeUnlocked|");    
  1886.     if(msg & MNodeMessage::AttributeMessage::kAttributeAdded)
  1887.         DXCC_DPFA_SHORT("kAttributeAdded|");    
  1888.     if(msg & MNodeMessage::AttributeMessage::kAttributeRemoved)
  1889.         DXCC_DPFA_SHORT("kAttributeRemoved|");    
  1890.     if(msg & MNodeMessage::AttributeMessage::kAttributeRenamed)
  1891.         DXCC_DPFA_SHORT("kAttributeRenamed|");    
  1892.     if(msg & MNodeMessage::AttributeMessage::kAttributeKeyable)
  1893.         DXCC_DPFA_SHORT("kAttributeKeyable|");    
  1894.     if(msg & MNodeMessage::AttributeMessage::kAttributeUnkeyable)
  1895.         DXCC_DPFA_SHORT("kAttributeUnkeyable|");    
  1896.     if(msg & MNodeMessage::AttributeMessage::kIncomingDirection)
  1897.         DXCC_DPFA_SHORT("kIncomingDirection|");    
  1898.     if(msg & MNodeMessage::AttributeMessage::kAttributeArrayAdded)
  1899.         DXCC_DPFA_SHORT("kAttributeArrayAdded|");
  1900.     if(msg & MNodeMessage::AttributeMessage::kAttributeArrayRemoved)
  1901.         DXCC_DPFA_SHORT("kAttributeArrayRemoved|");
  1902.     if(msg & MNodeMessage::AttributeMessage::kOtherPlugSet)
  1903.         DXCC_DPFA_SHORT("kOtherPlugSet|");
  1904.     DXCC_DPFA_MESSAGE(") %s <==> %s", plug.name().asChar(), otherPlug.name().asChar());
  1905. };
  1906.  
  1907. HRESULT CMayaPreviewPipeline::Tag_Dirty(MNodeMessage::AttributeMessage msg, 
  1908.                                                             MPlug & plug,
  1909.                                                             MPlug & otherPlug)
  1910. {
  1911.     HRESULT hr= S_OK;
  1912.     MStatus stat = MS::kSuccess;
  1913.  
  1914.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  1915.  
  1916.     const char* attrName= MFnAttribute(plug.attribute()).name().asChar();
  1917.     //DPF_DEPNodeAttributeChanged(msg, plug, otherPlug );
  1918.  
  1919.     if(msg&MNodeMessage::AttributeMessage::kAttributeEval
  1920.     || msg&MNodeMessage::AttributeMessage::kAttributeSet
  1921.     || msg&MNodeMessage::AttributeMessage::kAttributeAdded
  1922.     || msg&MNodeMessage::AttributeMessage::kAttributeRemoved
  1923.     || msg&MNodeMessage::AttributeMessage::kAttributeRenamed
  1924.     || msg&MNodeMessage::AttributeMessage::kAttributeArrayAdded
  1925.     || msg&MNodeMessage::AttributeMessage::kAttributeArrayRemoved
  1926.     || msg&MNodeMessage::AttributeMessage::kOtherPlugSet
  1927.     || msg&MNodeMessage::AttributeMessage::kConnectionMade)
  1928.     {
  1929.         if((attrName == strstr(attrName, "visibility"))//visibility
  1930.         || (attrName == strstr(attrName, "lodVisibility"))//visibility
  1931.         || (attrName == strstr(attrName, "overrideVisibility"))//visibility
  1932.         || (attrName == strstr(attrName, "overrideEnabled"))//visibility
  1933.         || (attrName == strstr(attrName, "intermediateObject")))//visibility
  1934.         {
  1935.             MItDag itDag;
  1936.             MDagPathArray PathArray;
  1937.  
  1938.             stat= MDagPath::getAllPathsTo(plug.node(), PathArray);
  1939.             for(UINT iPath= 0; iPath < PathArray.length(); iPath++)
  1940.             {
  1941.                 for( itDag.reset(PathArray[iPath]); !itDag.isDone(); itDag.next())
  1942.                 {
  1943.                     DCCTag* tag= NULL;
  1944.                     MDagPath dagLeaf;
  1945.                     itDag.getPath(dagLeaf);
  1946.  
  1947.                     if(!DAGIsVisible(dagLeaf, &stat))
  1948.                     {                        
  1949.                         UINT iRemove;
  1950.                         if(TagContainer.Find(dagLeaf, &iRemove, &tag))
  1951.                         {
  1952.                             MDagPath dagParent= dagLeaf;
  1953.                             dagParent.pop();
  1954.                             Tag_Reparent(MDagMessage::DagMessage::kParentRemoved, dagLeaf, dagParent, false);
  1955.                             TagContainer.Erase(iRemove);
  1956.                         }
  1957.                     }
  1958.                     else
  1959.                     {
  1960.                         TagContainer.Add(dagLeaf, NULL, NULL);
  1961.                     }        
  1962.                 }
  1963.             }
  1964.         }
  1965.         else 
  1966.         //((0 == lstrcmpA(attrName, "outMesh"))//generic mesh update
  1967.         //|| (attrName == strstr(attrName, "pnts"))//vertex movement
  1968.         //|| (attrName == strstr(attrName, "instObjGroups"))//material assignment
  1969.         //|| (attrName == strstr(attrName, "translate"))//transform
  1970.         //|| (attrName == strstr(attrName, "rotate"))//transform
  1971.         //|| (attrName == strstr(attrName, "scale")))//transform
  1972.         {
  1973.             MDagPathArray PathArray;
  1974.  
  1975.             stat= MDagPath::getAllPathsTo(plug.node(), PathArray);
  1976.             for(UINT iPath= 0; iPath < PathArray.length(); iPath++)
  1977.             {
  1978.                 DCCTag* tag= NULL;
  1979.                 if(TagContainer.Find(PathArray[iPath], NULL, &tag))
  1980.                 {
  1981. #ifdef MAYA_ATTRIBUTE_DEBUG
  1982.                     tag->AttributeChanged.append(MFnAttribute(plug.attribute()).name());
  1983. #endif
  1984.                     TagContainer.MarkAsDirty(tag);
  1985.                 }
  1986.             }
  1987.         }
  1988.          
  1989.     }
  1990.  
  1991.     DXCC_ASSERT_EXCEPTIONS_END()
  1992.  
  1993. //e_Exit:
  1994.     return hr;
  1995. }
  1996.  
  1997. D3DXMATRIX& CMayaPreviewPipeline::PerspectiveCamera_GetView()
  1998. {
  1999.     return PerspectiveCamera_View;
  2000. }
  2001.  
  2002. D3DXMATRIX& CMayaPreviewPipeline::PerspectiveCamera_GetProjection()
  2003. {
  2004.     return PerspectiveCamera_Projection;
  2005. }
  2006.  
  2007. HRESULT CMayaPreviewPipeline::Synchronize_PerspectiveCamera()
  2008. {
  2009.     MDagPath MayaCamera;
  2010.     M3dView panel;
  2011.     for(UINT iView= 0; iView < M3dView::numberOf3dViews(); iView++)
  2012.     {
  2013.         D3DXMATRIXA16 mCamera;
  2014.         M3dView::get3dView(iView, panel);
  2015.         panel.getCamera(MayaCamera);
  2016.         MayaCamera.pop();
  2017.         //const char* cameraName= MayaCamera.partialPathName().asChar();
  2018.         if(MayaCamera.partialPathName() == MString("persp"))
  2019.         {
  2020.             MayaCamera.extendToShape();
  2021.             MFloatMatrix fView(MayaCamera.inclusiveMatrix().matrix );
  2022.  
  2023.             ConvertWorldMatrix(mCamera, fView);
  2024.  
  2025.             panel.getCamera(MayaCamera);
  2026.             MFnCamera fnMayaCamera(MayaCamera.node());
  2027.  
  2028.             MVector mUp= fnMayaCamera.upDirection();
  2029.             MVector mAt= fnMayaCamera.viewDirection();
  2030.             MPoint mEye= fnMayaCamera.eyePoint(MSpace::kWorld);
  2031.             
  2032.             D3DXVECTOR3 dxEye( (float)-mEye.x, (float)mEye.y, (float)mEye.z );
  2033.             D3DXVECTOR3 dxAt( (float)-mAt.x, (float)mAt.y, (float)mAt.z );
  2034.             D3DXVECTOR3 dxUp( (float)-mUp.x, (float)mUp.y, (float)mUp.z );
  2035.             D3DXVECTOR4 fEye;
  2036.             D3DXVECTOR4 fAt;
  2037.             D3DXVECTOR3 fUp;
  2038.  
  2039.             D3DXVec3Transform(&fEye, &dxEye,(D3DXMATRIX*)&mCamera);
  2040.             D3DXVec3Transform(&fAt, &dxAt,(D3DXMATRIX*)&mCamera);
  2041.             D3DXVec3TransformNormal(&fUp, &dxUp,(D3DXMATRIX*)&mCamera);
  2042.             
  2043.             
  2044.             D3DXMatrixLookAtLH(&PerspectiveCamera_View, 
  2045.                 (D3DXVECTOR3*)&fEye,
  2046.                 (D3DXVECTOR3*)&fAt,
  2047.                 &fUp);          
  2048.  
  2049.             // Projection matrix
  2050.             float zNear = fnMayaCamera.nearClippingPlane();
  2051.             float zFar = fnMayaCamera.farClippingPlane();
  2052.             float hFOV = fnMayaCamera.horizontalFieldOfView();
  2053.             float f = 1.0f / tan( hFOV / 2 );
  2054.  
  2055.             ZeroMemory( &PerspectiveCamera_Projection, sizeof(PerspectiveCamera_Projection) );
  2056.             PerspectiveCamera_Projection._11 = f;
  2057.             PerspectiveCamera_Projection._22 = f;
  2058.             PerspectiveCamera_Projection._33 = (zFar+zNear) / (zFar-zNear);
  2059.             PerspectiveCamera_Projection._34 = 1.0f;
  2060.             PerspectiveCamera_Projection._43 = -2 * (zFar*zNear)/(zFar-zNear);
  2061.             
  2062.             break;
  2063.         }
  2064.     }
  2065.     return S_OK;
  2066. }
  2067.  
  2068.  
  2069. HRESULT CMayaPreviewPipeline::Synchronize_Node(MObject & node)
  2070. {
  2071.     HRESULT hr= S_OK;
  2072.     MStatus stat= MS::kSuccess;
  2073.  
  2074.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  2075.  
  2076.     MDagPathArray PathArray;
  2077.  
  2078.     stat= MDagPath::getAllPathsTo(node, PathArray);
  2079.     for(UINT iPath= 0; iPath < PathArray.length(); iPath++)
  2080.     {
  2081.         hr= Synchronize_DagPath(PathArray[iPath]);
  2082.         if(DXCC_FAILED(hr))
  2083.             DXCC_GOTO_EXIT(e_Exit, TRUE);
  2084.     }
  2085.     
  2086.     DXCC_ASSERT_EXCEPTIONS_END()
  2087.  
  2088. e_Exit:
  2089.     return hr;
  2090. }
  2091.  
  2092. HRESULT CMayaPreviewPipeline::Synchronize_DagPath(MDagPath &path)
  2093. {
  2094.     HRESULT hr= S_OK;
  2095.     MStatus stat= MS::kSuccess;
  2096.  
  2097.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  2098.  
  2099.     if(path.node().hasFn(MFn::kMesh)
  2100.         || path.node().hasFn(MFn::kTransform))
  2101.     {
  2102.         DCCTag *tag= NULL;
  2103.         
  2104.         if(!TagContainer.Add(path, NULL, &tag))
  2105.             DXCC_STATUS_EXIT(hr, S_OK, e_Exit, FALSE);
  2106.  
  2107.  
  2108.         hr= Synchronize_Tag(tag);
  2109.         if(DXCC_FAILED(hr))
  2110.             DXCC_GOTO_EXIT(e_Exit, TRUE);    
  2111.     }
  2112.  
  2113.     DXCC_ASSERT_EXCEPTIONS_END()
  2114.  
  2115. e_Exit:
  2116.     return S_OK;
  2117. }
  2118.  
  2119. HRESULT CMayaPreviewPipeline::Synchronize_Tag(DCCTag *pTag)
  2120. {
  2121.     HRESULT hr= S_OK;
  2122.     MStatus stat= MS::kSuccess;
  2123.  
  2124.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  2125.  
  2126. #ifdef MAYA_ATTRIBUTE_DEBUG
  2127.     DXCC_DPF_HEADER(TEXT("INFO"));
  2128.     DXCC_DPFA_MESSAGE("ATTRIBUTES: ");
  2129.     for(UINT i= 0; i < pTag->AttributeChanged.length(); i++)
  2130.     {
  2131.         DXCCDebugPrintfA(pTag->AttributeChanged[i].asChar());
  2132.         DXCCDebugPrintfA(" && ");
  2133.     }
  2134.     DXCC_DPFA_MESSAGE("");
  2135.     pTag->AttributeChanged.clear();
  2136. #endif
  2137.  
  2138.     if(pTag->GetPath().node().hasFn(MFn::kMesh))    
  2139.     {
  2140.         return Synchronize_Mesh(pTag);
  2141.     }
  2142.     else// if(pTag->Path.node().hasFn(MFn::kTransform))
  2143.     {
  2144.         return Synchronize_Frame(pTag);
  2145.     }
  2146.  
  2147.     DXCC_ASSERT_EXCEPTIONS_END()
  2148.  
  2149. //e_Exit:
  2150.     return S_OK;
  2151. }
  2152.  
  2153. HRESULT
  2154. CMayaPreviewPipeline::Synchronize_Frame(DCCTag *pTag)
  2155. {
  2156.     HRESULT hr= S_OK;
  2157.     MStatus stat= MS::kSuccess;
  2158.     D3DXMATRIX d3dMatrix;
  2159.  
  2160.     if(!pTag)
  2161.         return E_INVALIDARG;
  2162.  
  2163.  
  2164.  
  2165.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  2166.  
  2167.     MDagPath dagTag= pTag->GetPath();
  2168.  
  2169.     //Create the frame???
  2170.     if(!pTag->IsInitialized())
  2171.     {
  2172.         hr= DXCCCreateFrame((LPDXCCFRAME*)&pTag->Interface);
  2173.         if(DXCC_FAILED(hr))
  2174.             DXCC_GOTO_EXIT(e_Exit, TRUE);
  2175.  
  2176.         hr= AccessManager()->RecycleResource(pTag->Resource->GetHandle(), pTag->Interface, IID_IDXCCFrame, TRUE, FALSE);
  2177.         if(DXCC_FAILED(hr))
  2178.             DXCC_GOTO_EXIT(e_Exit, TRUE);
  2179.  
  2180.         hr= pTag->Resource->SetName(MakeNameExportable(dagTag.partialPathName()).asChar());
  2181.         if(DXCC_FAILED(hr))
  2182.             DXCC_GOTO_EXIT(e_Exit, TRUE);
  2183.  
  2184.         TriggerManagerEvents.OnResourceRecycle(pTag->Resource);
  2185.     }
  2186.  
  2187.     if(pTag->Resource != NULL 
  2188.         && pTag->Resource->GetIID() != IID_IDXCCFrame)
  2189.     {
  2190.         DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  2191.     }
  2192.  
  2193.     DXCC_DPFA("FRAME_SYNC: %s", dagTag.fullPathName().asChar());
  2194.  
  2195.     D3DXMatrixIdentity(&d3dMatrix);
  2196.     if(dagTag.node().hasFn(MFn::kTransform))
  2197.     {
  2198.         MMatrix localMatrix;
  2199.         MFnTransform fnTransform(dagTag.node(), &stat);
  2200.         if(MAYA_FAILED(stat))
  2201.             DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  2202.  
  2203.         localMatrix= fnTransform.transformation(&stat).asMatrix();
  2204.         if(MAYA_FAILED(stat))
  2205.             DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  2206.  
  2207.         ConvertLocalMatrix(d3dMatrix, localMatrix);
  2208.  
  2209.     }
  2210.  
  2211.     hr= ((LPDXCCFRAME)pTag->Interface)->SetLocalMatrix(&d3dMatrix);
  2212.     if(DXCC_FAILED(hr))
  2213.         DXCC_GOTO_EXIT(e_Exit, TRUE);
  2214.  
  2215.     DXCC_ASSERT_EXCEPTIONS_END()
  2216.  
  2217. e_Exit:
  2218.     return hr;
  2219. };
  2220.  
  2221. HRESULT CMayaPreviewPipeline::Mesh_GatherMeshInfo(MFnMesh& fnMesh, DCCMeshInfo& MayaMeshInfo)
  2222. {
  2223.     HRESULT hr= S_OK;
  2224.     MStatus stat = MS::kSuccess;
  2225.  
  2226.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  2227.  
  2228.     //CALCULATE TRIANGLES AND VERTICES
  2229.     MItMeshPolygon itMeshPoly(MObject::kNullObj);
  2230.     MItMeshVertex itMeshVert(MObject::kNullObj);
  2231.  
  2232.     DXCC_ASSERT(!fnMesh.object().isNull());
  2233.  
  2234.     stat = itMeshPoly.reset(fnMesh.object());
  2235.     if(MAYA_FAILED(stat))
  2236.     {
  2237.         DXCC_DPF_ERROR(TEXT("Could not reset Poly iterator."));
  2238.         DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  2239.     }
  2240.     for (; !itMeshPoly.isDone(); itMeshPoly.next())
  2241.     {
  2242.         int cPolyTriCount;
  2243.         UINT cPolyonVerticesMaya;
  2244.         
  2245.         cPolyonVerticesMaya= itMeshPoly.polygonVertexCount(&stat);
  2246.         if(MAYA_FAILED(stat))
  2247.         {
  2248.             DXCC_DPF_ERROR(TEXT("polygonVertexCount"));
  2249.             DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  2250.         }
  2251.  
  2252.         stat= itMeshPoly.numTriangles(cPolyTriCount);
  2253.         if(MAYA_FAILED(stat))
  2254.         {
  2255.             DXCC_DPF_ERROR(TEXT("numTriangles"));
  2256.             DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  2257.         }
  2258.  
  2259.         MayaMeshInfo.cD3DTriangles+= cPolyTriCount;
  2260.         MayaMeshInfo.cD3DVertices+= cPolyonVerticesMaya;
  2261.     }
  2262.     //END//CALCULATE TRIANGLES AND VERTICES
  2263.  
  2264.     hr= Mesh_GatherVertexInfo(fnMesh, MayaMeshInfo.VertexInfo);
  2265.     if(DXCC_FAILED(hr))
  2266.         DXCC_GOTO_EXIT(e_Exit, TRUE);
  2267.  
  2268.     DXCC_ASSERT_EXCEPTIONS_END()
  2269.  
  2270. e_Exit:
  2271.     return hr;
  2272. }
  2273.  
  2274. HRESULT CMayaPreviewPipeline::Mesh_GatherVertexInfo(MFnMesh& fnMesh, DCCVertexInfo& MayaVertexInfo)
  2275. {
  2276.     HRESULT hr= S_OK;
  2277.     MStatus stat = MS::kSuccess;
  2278.  
  2279.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  2280.  
  2281.     //CALCULATE UV SET QUANTITY
  2282.     MayaVertexInfo.cUVs= fnMesh.numUVSets(&stat);
  2283.     if(MAYA_FAILED(stat))
  2284.     {
  2285.         DXCC_DPF_ERROR(TEXT("Unable to retrieve UV count."));
  2286.         DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  2287.     }
  2288.  
  2289.     stat= fnMesh.getUVSetNames ( MayaVertexInfo.UVNames ); 
  2290.     if(MAYA_FAILED(stat))
  2291.     {
  2292.         DXCC_DPF_ERROR(TEXT("Unable to retrieve UV set names."));
  2293.         DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  2294.     }
  2295.  
  2296.     stat= MayaVertexInfo.Ucoords.setLength(MayaVertexInfo.cUVs);
  2297.     if(MAYA_FAILED(stat))
  2298.     {
  2299.         DXCC_DPF_ERROR(TEXT("Unable to resize UV UCoord Array."));
  2300.         DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  2301.     }
  2302.  
  2303.     stat= MayaVertexInfo.Vcoords.setLength(MayaVertexInfo.cUVs);
  2304.     if(MAYA_FAILED(stat))
  2305.     {
  2306.         DXCC_DPF_ERROR(TEXT("Unable to resize UV VCoord Array."));
  2307.         DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  2308.     }
  2309.  
  2310.     DXCC_ASSERT_EXCEPTIONS_END()
  2311.  
  2312. e_Exit:
  2313.     return hr;
  2314.  
  2315. }
  2316.  
  2317. HRESULT    
  2318. CMayaPreviewPipeline::Mesh_CreateOrRecycle(DCCTag *pTag, MFnMesh &fnMesh, DCCMeshInfo &MayaMeshInfo)
  2319. {
  2320.     HRESULT hr= S_OK;
  2321.     MStatus stat = MS::kSuccess;
  2322.  
  2323.     LPDXCCDECLARATION    dxDeclaration= NULL; 
  2324.     LPDXCCMESH            dxMesh= NULL;    
  2325.     LPMESHUSERDATA        dxMeshUserData= NULL;
  2326.     LPDIRECT3DDEVICE9    dxDevice= NULL;
  2327.  
  2328.     if(!pTag)
  2329.         return E_INVALIDARG;
  2330.  
  2331.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  2332.     
  2333.     MDagPath dagTag= pTag->GetPath();
  2334.  
  2335.     hr= pTag->Resource->GetUserData(NULL, (void**) &dxMeshUserData, NULL);
  2336.     if(DXCC_FAILED(hr))
  2337.         DXCC_GOTO_EXIT(e_Exit, TRUE);
  2338.  
  2339.     if( pTag->IsInitialized()
  2340.         && dxMeshUserData != NULL 
  2341.         && dxMeshUserData->cMayaPolygons == fnMesh.numPolygons()
  2342.         && dxMeshUserData->cMayaEdges == fnMesh.numEdges()
  2343.         && dxMeshUserData->cMayaFaceVertices == fnMesh.numFaceVertices()
  2344.         && dxMeshUserData->cMayaUVs == fnMesh.numUVs()
  2345.         && dxMeshUserData->cMayaUVSets == fnMesh.numUVSets()
  2346.         && dxMeshUserData->cMayaVertices == fnMesh.numVertices())
  2347.     {
  2348.         pTag->Interface->AddRef();
  2349.         dxMesh= (LPDXCCMESH)pTag->Interface;    
  2350.  
  2351.         dxMesh->RemoveAllAttributedMaterials();
  2352.  
  2353.         MayaMeshInfo.cD3DVertices=  dxMesh->NumVertices();
  2354.         MayaMeshInfo.cD3DTriangles=  dxMesh->NumFaces();
  2355.  
  2356.         DXCC_RELEASE(dxMesh);
  2357.  
  2358.         hr= Mesh_GatherVertexInfo(fnMesh, MayaMeshInfo.VertexInfo);
  2359.         if(DXCC_FAILED(hr))
  2360.             DXCC_GOTO_EXIT(e_Exit, TRUE);
  2361.  
  2362.         MeshCleanUserData(dxMeshUserData, fnMesh.numVertices(), MayaMeshInfo.cD3DVertices );
  2363.     }
  2364.     else
  2365.     {
  2366.         //must come before MeshCreateUserData to fill in MayaMeshInfo.cD3DVertices
  2367.         hr= Mesh_GatherMeshInfo(fnMesh, MayaMeshInfo);
  2368.         if(DXCC_FAILED(hr))
  2369.             DXCC_GOTO_EXIT(e_Exit, TRUE);
  2370.  
  2371.         //must come after Mesh_GatherMeshInfo to fill in MayaMeshInfo.cD3DVertices
  2372.         dxMeshUserData= MeshCreateUserData(pTag->Resource, fnMesh.numVertices(), MayaMeshInfo.cD3DVertices);
  2373.         if(!dxMeshUserData)
  2374.             DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  2375.  
  2376.         dxMeshUserData->cMayaPolygons= fnMesh.numPolygons();
  2377.         dxMeshUserData->cMayaEdges= fnMesh.numEdges();
  2378.         dxMeshUserData->cMayaFaceVertices= fnMesh.numFaceVertices();
  2379.         dxMeshUserData->cMayaUVs= fnMesh.numUVs();
  2380.         dxMeshUserData->cMayaUVSets= fnMesh.numUVSets();
  2381.         dxMeshUserData->cMayaVertices= fnMesh.numVertices();
  2382.     
  2383.  
  2384.         hr= DXCCCreateDeclaration(&dxDeclaration);
  2385.         if(DXCC_FAILED(hr))
  2386.             DXCC_GOTO_EXIT(e_Exit, TRUE);
  2387.  
  2388.         hr= dxDeclaration->InsertPositionElement(dxDeclaration->NumElements());
  2389.         if(DXCC_FAILED(hr))
  2390.             DXCC_GOTO_EXIT(e_Exit, TRUE);
  2391.  
  2392.         hr= dxDeclaration->InsertNormalElement(dxDeclaration->NumElements());
  2393.         if(DXCC_FAILED(hr))
  2394.             DXCC_GOTO_EXIT(e_Exit, TRUE);
  2395.  
  2396.         hr= dxDeclaration->InsertDiffuseElement(dxDeclaration->NumElements());
  2397.         if(DXCC_FAILED(hr))
  2398.             DXCC_GOTO_EXIT(e_Exit, TRUE);
  2399.  
  2400.         for(UINT iTex= 0; iTex < MayaMeshInfo.VertexInfo.cUVs; iTex++)
  2401.         {
  2402.             hr=dxDeclaration->InsertTexcoordElement(dxDeclaration->NumElements(), iTex, 2, MayaMeshInfo.VertexInfo.UVNames[iTex].asChar() );
  2403.             if(DXCC_FAILED(hr))
  2404.                 DXCC_GOTO_EXIT(e_Exit, TRUE);
  2405.         }
  2406.  
  2407.         hr= AccessEngine()->GetD3DDevice(&dxDevice);
  2408.         if(DXCC_FAILED(hr))
  2409.             DXCC_GOTO_EXIT(e_Exit, TRUE);
  2410.  
  2411.         if(pTag->IsInitialized())
  2412.         {
  2413.             pTag->Interface->AddRef();
  2414.             dxMesh= (LPDXCCMESH)pTag->Interface;    
  2415.  
  2416.  
  2417.             hr= ((LPDXCCMESH)pTag->Interface)->Recycle(
  2418.                     MayaMeshInfo.cD3DTriangles,
  2419.                     MayaMeshInfo.cD3DVertices,
  2420.                     dxDevice,
  2421.                     dxDeclaration->GetElements());
  2422.             if(DXCC_FAILED(hr))
  2423.                 DXCC_GOTO_EXIT(e_Exit, TRUE);
  2424.  
  2425.         }
  2426.         else
  2427.         {
  2428. //            DXCC_DPFA("MESH_INIT: %s", dagTag.fullPathName().asChar());
  2429.  
  2430.             hr= DXCCCreateMesh(MayaMeshInfo.cD3DTriangles, MayaMeshInfo.cD3DVertices, dxDevice, dxDeclaration->GetElements(), (LPDXCCMESH*)&pTag->Interface);
  2431.             if(DXCC_FAILED(hr))
  2432.                 DXCC_GOTO_EXIT(e_Exit, TRUE);
  2433.  
  2434.             hr= AccessManager()->RecycleResource(pTag->Resource->GetHandle(), pTag->Interface, IID_IDXCCMesh, TRUE, FALSE );
  2435.             if(DXCC_FAILED(hr))
  2436.                 DXCC_GOTO_EXIT(e_Exit, TRUE);
  2437.  
  2438.             hr= pTag->Resource->SetName(MakeNameExportable(dagTag.partialPathName()).asChar());
  2439.             if(DXCC_FAILED(hr))
  2440.                 DXCC_GOTO_EXIT(e_Exit, TRUE);
  2441.  
  2442.             TriggerManagerEvents.OnResourceRecycle(pTag->Resource);
  2443.         }
  2444.     }
  2445.  
  2446.  
  2447.  
  2448.     DXCC_ASSERT_EXCEPTIONS_END()
  2449.  
  2450. e_Exit:
  2451.     DXCC_RELEASE(dxDevice);
  2452.     DXCC_RELEASE(dxDeclaration);
  2453.     DXCC_RELEASE(dxMesh);
  2454.  
  2455.     return hr;
  2456. }
  2457.  
  2458.  
  2459. HRESULT    
  2460. CMayaPreviewPipeline::Synchronize_Mesh(DCCTag *pTag)
  2461. {
  2462.     HRESULT hr= S_OK;
  2463.     MStatus stat = MS::kSuccess;
  2464.     
  2465.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  2466.  
  2467.     MFnSkinCluster SkinCluster;
  2468.     MFnMesh fnMesh;
  2469.  
  2470.     MItMeshPolygon itMeshPoly(MObject::kNullObj);
  2471.     MItMeshVertex itMeshVert(MObject::kNullObj);
  2472.     MObjectArray Shaders;
  2473.     MIntArray Attributes; 
  2474.     MDagPath dagTag= pTag->GetPath();
  2475.     MDagPath dagParent= dagTag;
  2476.     DCCTag *pTagParent= NULL;
  2477.     dagParent.pop();
  2478.  
  2479.  
  2480.     DCCMeshInfo MeshInfo;
  2481.     UINT iVertexD3D=0;
  2482.     UINT iTriangleD3D= 0;
  2483.     FLOAT fDeterminant=-1;
  2484.     DXCCFLOAT4 f4;
  2485.     LPDXCCVERTEXBUNDLER dxVertexBundler= NULL;
  2486.     LPDXCCMESH dxMesh= NULL;    
  2487.     LPMESHUSERDATA    dxMeshUserData= NULL;
  2488.  
  2489.     DXCC_DPFA("MESH_SYNC: %s", dagTag.fullPathName().asChar());
  2490.  
  2491.  
  2492.     if(TagContainer.Find(dagParent, NULL, &pTagParent)
  2493.         && pTagParent->Interface)
  2494.     {
  2495.         fDeterminant= D3DXMatrixDeterminant(((LPDXCCFRAME)pTagParent->Interface)->GetWorldMatrix());
  2496.     }
  2497.     
  2498.     stat = fnMesh.setObject(dagTag.node());
  2499.     if(MAYA_FAILED(stat))
  2500.     {
  2501.         DXCC_DPF_ERROR(TEXT("Object could not be read as mesh."));
  2502.         DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, FALSE);
  2503.     }
  2504.  
  2505.     hr= Mesh_CreateOrRecycle(pTag, fnMesh, MeshInfo);
  2506.     if(DXCC_FAILED(hr))
  2507.         DXCC_GOTO_EXIT(e_Exit, TRUE);
  2508.  
  2509.     hr= pTag->Resource->GetUserData(NULL, (void**) &dxMeshUserData, NULL);
  2510.     if(DXCC_FAILED(hr))
  2511.         DXCC_GOTO_EXIT(e_Exit, TRUE);
  2512.     pTag->Interface->AddRef();
  2513.     dxMesh= (LPDXCCMESH)pTag->Interface;
  2514.  
  2515.     //AND ATTRIBUTE BUFFER
  2516.  
  2517.     UINT instNum= dagTag.instanceNumber();
  2518.     stat= fnMesh.getConnectedShaders(dagTag.instanceNumber(), Shaders, Attributes);
  2519.     if(MAYA_FAILED(stat))
  2520.     {
  2521.         DXCC_DPF_ERROR(TEXT("Could not get Mesh Shaders"));
  2522.         DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  2523.     }
  2524.     UINT NumShaders= Shaders.length();
  2525.     UINT NumAttributes= Attributes.length();
  2526.  
  2527.     hr= Mesh_GatherMaterials(Shaders, dxMesh);
  2528.     if(DXCC_FAILED(hr))
  2529.         DXCC_GOTO_EXIT( e_Exit, TRUE);
  2530.  
  2531.     if(UI_GetSkinState())
  2532.     {
  2533.         hr= Mesh_FindSkin(fnMesh, SkinCluster);
  2534.         if(DXCC_FAILED(hr))
  2535.             DXCC_GOTO_EXIT( e_Exit, TRUE);
  2536.     }
  2537.  
  2538.     hr= dxMesh->LockFaces();
  2539.     if(DXCC_FAILED(hr))
  2540.         DXCC_GOTO_EXIT(e_Exit, TRUE);
  2541.  
  2542.     hr= dxMesh->GetVertexBundler(&dxVertexBundler);
  2543.     if(DXCC_FAILED(hr))
  2544.         DXCC_GOTO_EXIT(e_Exit, TRUE);
  2545.  
  2546.     hr= dxVertexBundler->LockAll();
  2547.     if(DXCC_FAILED(hr))
  2548.         DXCC_GOTO_EXIT(e_Exit, TRUE);
  2549.         
  2550.     stat = itMeshPoly.reset(fnMesh.object());
  2551.     if(MAYA_FAILED(stat))
  2552.     {
  2553.         DXCC_DPF_ERROR(TEXT("Could not reset Poly iterator."));
  2554.         DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  2555.     }
  2556.  
  2557.     stat = itMeshVert.reset(fnMesh.object());
  2558.     if(MAYA_FAILED(stat))
  2559.     {
  2560.         DXCC_DPF_ERROR(TEXT("Could not reset Poly Vertex iterator."));
  2561.         DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  2562.     }
  2563.  
  2564.     //PolygonLoop
  2565.     iVertexD3D=0;
  2566.     iTriangleD3D=0;
  2567.     for (int iPolygonMaya = 0; 
  2568.         !itMeshPoly.isDone(); 
  2569.         iPolygonMaya++, itMeshPoly.next())
  2570.     {
  2571.         MVector            PolygonNormalMaya;
  2572.         D3DXVECTOR3        PolygonNormalD3D;
  2573.         int                cPolyonTrianglesMaya;
  2574.         UINT            cPolyonVerticesMaya= itMeshPoly.polygonVertexCount(&stat);
  2575.         if(MAYA_FAILED(stat))
  2576.         {
  2577.             DXCC_DPF_ERROR(TEXT("polygonVertexCount"));
  2578.             DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  2579.         }
  2580.  
  2581.         stat= itMeshPoly.getNormal(PolygonNormalMaya, MSpace::kObject); 
  2582.         if(MAYA_FAILED(stat))
  2583.         {
  2584.             DXCC_DPF_ERROR(TEXT("Could not retrieve polygon(%d) normal."), iPolygonMaya);
  2585.             DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  2586.         }
  2587.         f4.Encode(&PolygonNormalMaya.x, 3);
  2588.         f4.Decode(&PolygonNormalD3D);
  2589.  
  2590.         //PolygonVertexLoop
  2591.         for(UINT iPolygonVertexMaya= 0; 
  2592.             iPolygonVertexMaya < cPolyonVerticesMaya; 
  2593.             iPolygonVertexMaya++, iVertexD3D++)
  2594.             //,itPolyVert.next()
  2595.         {
  2596.             int unused;
  2597.             int iMeshVertexMaya= itMeshPoly.vertexIndex(iPolygonVertexMaya, &stat);
  2598.             if(MAYA_FAILED(stat))
  2599.             {
  2600.                 DXCC_DPF_ERROR(TEXT("Could not retrieve mesh vertex from polygon(%d) vertex(%d)."), iPolygonMaya, iPolygonVertexMaya);
  2601.                 DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  2602.             }
  2603.  
  2604.             stat= itMeshVert.setIndex(iMeshVertexMaya, unused);
  2605.             if(MAYA_FAILED(stat))
  2606.             {
  2607.                 DXCC_DPF_ERROR(TEXT("Could not retrieve vertex(%d) iterator"), iMeshVertexMaya);
  2608.                 DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  2609.             }
  2610.  
  2611.  
  2612.             MeshGlobal.VertexD3DToMaya[iVertexD3D].MayaPolygon= iPolygonMaya;
  2613.             MeshGlobal.VertexD3DToMaya[iVertexD3D].MayaVertex= iMeshVertexMaya;    
  2614.             if(MeshGlobal.VertexMayaToD3D[iMeshVertexMaya].D3DFirstPointRep == UNUSED32)
  2615.             {//link to D3DFirstPointRep&D3DLastPointRep if not hooked up
  2616.                 MeshGlobal.VertexMayaToD3D[iMeshVertexMaya].D3DFirstPointRep= iVertexD3D;
  2617.                 MeshGlobal.VertexMayaToD3D[iMeshVertexMaya].D3DLastPointRep= iVertexD3D;
  2618.  
  2619.                 MeshGlobal.D3DPointReps[iVertexD3D]=  iVertexD3D;
  2620.             }
  2621.             else
  2622.             {//link to D3DNextPointRep&D3DLastPointRep
  2623.                 DWORD iFirstPointRepD3D = MeshGlobal.VertexMayaToD3D[iMeshVertexMaya].D3DFirstPointRep;
  2624.                 DWORD iLastPointRepD3D = MeshGlobal.VertexMayaToD3D[iMeshVertexMaya].D3DLastPointRep;
  2625.                 MeshGlobal.VertexD3DToMaya[iLastPointRepD3D].D3DNextPointRep= iVertexD3D;    
  2626.                 MeshGlobal.VertexMayaToD3D[iMeshVertexMaya].D3DLastPointRep= iVertexD3D;
  2627.  
  2628.                 MeshGlobal.D3DPointReps[iVertexD3D]= iFirstPointRepD3D;
  2629.             }
  2630.  
  2631.  
  2632.             MeshInfo.VertexInfo.position= itMeshVert.position ( MSpace::kObject, &stat); 
  2633.             if(MAYA_FAILED(stat))
  2634.             {
  2635.                 DXCC_DPF_ERROR(TEXT("Could not retrieve polygon(%d) Vertex(%d)"), iPolygonMaya, iPolygonVertexMaya);
  2636.                 DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  2637.             }
  2638.  
  2639.             hr= dxVertexBundler->SetPosition(iVertexD3D, f4.Encode(&MeshInfo.VertexInfo.position.x, 4));
  2640.             if(DXCC_FAILED(hr))
  2641.                 DXCC_GOTO_EXIT(e_Exit, TRUE);
  2642.  
  2643.             stat= itMeshVert.getNormal(MeshInfo.VertexInfo.normal, iPolygonMaya, MSpace::kObject); 
  2644.             if(MAYA_FAILED(stat))
  2645.             {
  2646.                 MeshInfo.VertexInfo.normal= PolygonNormalMaya;
  2647.                 stat= MStatus::MStatusCode::kSuccess;
  2648.             }
  2649.  
  2650.             hr= dxVertexBundler->SetNormal(iVertexD3D, f4.Encode(&MeshInfo.VertexInfo.normal.x, 3));
  2651.             if(DXCC_FAILED(hr))
  2652.                 DXCC_GOTO_EXIT(e_Exit, TRUE);
  2653.  
  2654.  
  2655.             for(UINT iUV= 0; iUV < MeshInfo.VertexInfo.UVNames.length(); iUV++)
  2656.             {
  2657.                 float2 uvPoint;
  2658.                 if(MAYA_SUCCEEDED(itMeshVert.getUV(iPolygonMaya, uvPoint,  &MeshInfo.VertexInfo.UVNames[iUV])))
  2659.                 {
  2660.                     MeshInfo.VertexInfo.Ucoords[iUV]= uvPoint[0];
  2661.                     MeshInfo.VertexInfo.Vcoords[iUV]= uvPoint[1];
  2662.                 }
  2663.                 else
  2664.                 {
  2665.                     MeshInfo.VertexInfo.Ucoords[iUV]= 0.0f;
  2666.                     MeshInfo.VertexInfo.Vcoords[iUV]= 0.0f;
  2667.                 }
  2668.  
  2669.                 hr= dxVertexBundler->SetTexcoord(iVertexD3D, iUV, f4.Encode(&D3DXVECTOR2(MeshInfo.VertexInfo.Ucoords[iUV], 1.0f-MeshInfo.VertexInfo.Vcoords[iUV])));
  2670.                 if(DXCC_FAILED(hr))
  2671.                     DXCC_GOTO_EXIT(e_Exit, TRUE);
  2672.             }
  2673.  
  2674.             if(itMeshVert.hasColor())
  2675.             {
  2676.                 if(!MAYA_FAILED(itMeshVert.getColor(MeshInfo.VertexInfo.color, iPolygonMaya)))
  2677.                 {
  2678.                     hr= dxVertexBundler->SetDiffuse(iVertexD3D, f4.Encode(&MeshInfo.VertexInfo.color.r, 4));
  2679.                     if(DXCC_FAILED(hr))
  2680.                         DXCC_GOTO_EXIT(e_Exit, TRUE);
  2681.                 }
  2682.             }
  2683.  
  2684.         }//END//PolygonVertexLoop
  2685.         
  2686.         stat= itMeshPoly.numTriangles(cPolyonTrianglesMaya);
  2687.         if(MAYA_FAILED(stat))
  2688.         {
  2689.             DXCC_DPF_ERROR(TEXT("Could not retrieve number of triangles."));
  2690.             DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  2691.         }
  2692.  
  2693.         //PolygonTriangleLoop
  2694.         for (int iPolyonTriangleMaya = 0; 
  2695.             iPolyonTriangleMaya < cPolyonTrianglesMaya; 
  2696.             iPolyonTriangleMaya++, iTriangleD3D++)
  2697.         {
  2698.             MPointArray            TrianglePointsMaya;
  2699.             MIntArray            TriangleVertexListMaya; //these are local to polygon
  2700.             D3DXPLANE            d3dxPlane;
  2701.             D3DXVECTOR3            v0,v1,v2;
  2702.             FLOAT                fDot;
  2703.             BOOL                bReverse= FALSE;
  2704.  
  2705.             stat= itMeshPoly.getTriangle(iPolyonTriangleMaya,  
  2706.                                          TrianglePointsMaya, //these are local to polygon
  2707.                                          TriangleVertexListMaya, 
  2708.                                          MSpace::Space::kObject );     
  2709.             if(MAYA_FAILED(stat))
  2710.             {
  2711.                 DXCC_DPF_ERROR(TEXT("Could not retrieve polygon(%d) triangle(%d)"), iPolygonMaya, iPolyonTriangleMaya);
  2712.                 DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  2713.             }
  2714.  
  2715.             if(TriangleVertexListMaya.length() != 3)
  2716.             {
  2717.                 DXCC_DPF_ERROR(TEXT("Polygon(%d) Triangle(%d) Size != 3"), iPolygonMaya, iPolyonTriangleMaya);
  2718.                 DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  2719.             }
  2720.  
  2721.  
  2722.             (MFloatVector(TrianglePointsMaya[0])).get((FLOAT*)v0);
  2723.             (MFloatVector(TrianglePointsMaya[1])).get((FLOAT*)v1);
  2724.             (MFloatVector(TrianglePointsMaya[2])).get((FLOAT*)v2);
  2725.  
  2726.  
  2727.             D3DXPlaneFromPoints(          
  2728.                 &d3dxPlane,
  2729.                 &v0,
  2730.                 &v1,
  2731.                 &v2);
  2732.  
  2733.             D3DXPlaneNormalize(&d3dxPlane, &d3dxPlane);
  2734.  
  2735.             fDot= D3DXVec3Dot((D3DXVECTOR3*)&d3dxPlane, &PolygonNormalD3D);
  2736.  
  2737. //            if((fDot >= 0.0f && fDeterminant < 0.0f) || (fDot < 0.0f && fDeterminant >= 0.0f))
  2738.             if(fDot*fDeterminant < 0.0f) 
  2739.             {
  2740.                 int swap= TriangleVertexListMaya[1];
  2741.                 TriangleVertexListMaya[1]= TriangleVertexListMaya[2];
  2742.                 TriangleVertexListMaya[2]=swap;
  2743.             }
  2744.  
  2745.             DXCC_ASSERT( TriangleVertexListMaya.length() == 3 );
  2746.             //TriangleVertexLoop
  2747.             for(int iTriangleVertex= 0; 
  2748.                 iTriangleVertex < 3; 
  2749.                 iTriangleVertex++)
  2750.             {
  2751.                 int iMeshVertexMaya;
  2752.                 int iPolygonVertexD3D;
  2753.  
  2754.                 iMeshVertexMaya= TriangleVertexListMaya[iTriangleVertex];
  2755.                 iPolygonVertexD3D= MeshGlobal.VertexMayaToD3D[iMeshVertexMaya].D3DLastPointRep;//since we work per-polygon, the last pointrep is always the newest
  2756.  
  2757.                 hr= dxMesh->SetFaceVertex(iTriangleD3D, iTriangleVertex, iPolygonVertexD3D);
  2758.                 if(DXCC_FAILED(hr))
  2759.                     DXCC_GOTO_EXIT(e_Exit, TRUE);
  2760.             }
  2761.  
  2762.             int attrib= Attributes[iPolygonMaya];
  2763.             if(attrib < 0 || attrib >= NumShaders)
  2764.                 attrib= 0;
  2765.  
  2766.             hr= dxMesh->SetFaceAttribute(iTriangleD3D, attrib );
  2767.             if(DXCC_FAILED(hr))
  2768.                 DXCC_GOTO_EXIT(e_Exit, TRUE);
  2769.  
  2770.         }//END//PolygonTriangleLoop
  2771.     }//END//PolygonLoop
  2772.  
  2773.     hr= dxVertexBundler->UnlockAll();
  2774.     if(DXCC_FAILED(hr))
  2775.         DXCC_GOTO_EXIT(e_Exit, TRUE);
  2776.  
  2777.     hr= dxMesh->UnlockFaces();
  2778.     if(DXCC_FAILED(hr))
  2779.         DXCC_GOTO_EXIT(e_Exit, TRUE);
  2780.  
  2781.     hr= dxMesh->ConvertPointRepsToAdjacency(MeshGlobal.D3DPointReps.GetData());
  2782.     if(DXCC_FAILED(hr))
  2783.         DXCC_GOTO_EXIT(e_Exit, TRUE);
  2784.  
  2785.  
  2786.     hr= dxMesh->Optimize( D3DXCLEAN_SIMPLIFICATION, D3DXMESHOPT_ATTRSORT|D3DXMESHOPT_COMPACT|D3DXMESHOPT_COMPACT, NULL, NULL);
  2787.     if(DXCC_FAILED(hr))
  2788.         DXCC_GOTO_EXIT(e_Exit, TRUE);
  2789.  
  2790.  
  2791.  
  2792.     if(UI_GetSkinState())
  2793.     {
  2794.         hr= Mesh_GatherSkin(pTag, SkinCluster);
  2795.         if(DXCC_FAILED(hr))
  2796.             DXCC_GOTO_EXIT( e_Exit, TRUE);
  2797.     }
  2798.  
  2799.  
  2800.     TriggerViewerEvents.OnMeshChange(dxMesh);
  2801.  
  2802.  
  2803. e_Exit:
  2804.     DXCC_RELEASE(dxVertexBundler);
  2805.     DXCC_RELEASE(dxMesh);
  2806.  
  2807.  
  2808.     DXCC_ASSERT_EXCEPTIONS_END()
  2809.  
  2810.     return hr;
  2811. }
  2812.  
  2813. HRESULT    
  2814. CMayaPreviewPipeline::Mesh_GatherMaterials( 
  2815.     MObjectArray& Shaders,  //shadingEngine nodes
  2816.     LPDXCCMESH pMesh)
  2817. {
  2818.     HRESULT hr= S_OK;
  2819.     MStatus stat= MS::kSuccess;
  2820.  
  2821.     LPDXCCRESOURCE pRes= NULL;
  2822.     ID3DXEffect* pD3DMaterial= NULL;
  2823.  
  2824.     //SHADER
  2825.     if(Shaders.length() > 0)
  2826.     {
  2827.         for(UINT iShader= 0; iShader < Shaders.length(); iShader++) //shadingEngine nodes
  2828.         {
  2829.             MFnDependencyNode shadingEngine(Shaders[iShader]);
  2830.             MPlug ShaderPlug;
  2831.             MPlugArray ShaderPlugArray;
  2832.  
  2833.             DXCC_RELEASE(pRes);
  2834.             DXCC_RELEASE(pD3DMaterial);
  2835.  
  2836.             BOOL bFoundShader= false;
  2837.  
  2838.             //TODO displacement or volume shaders too!
  2839.             ShaderPlug = shadingEngine.findPlug("surfaceShader", &stat); 
  2840.             if (MAYA_SUCCEEDED(stat) && !ShaderPlug.isNull()) //we have to find the plug but it doesnt have to be connected
  2841.             {
  2842.                 ShaderPlug.connectedTo(ShaderPlugArray, true, false); //the t
  2843.     
  2844.                 if (ShaderPlugArray.length() == 1) 
  2845.                 {
  2846.                     MFnDependencyNode shader(ShaderPlugArray[0].node());
  2847.                     int iHandle;
  2848.                     DXCCHANDLE hHandle;
  2849.                     MPlug plugResource= shader.findPlug(DirectXShader::aDXCCHandle);
  2850.                     plugResource.getValue(iHandle);
  2851.                     hHandle= (DXCCHANDLE)iHandle;
  2852.  
  2853.                     if(hHandle != NULL)
  2854.                     {
  2855.                         if(DXCC_SUCCEEDED(AccessManager()->FindResourceByHandle(hHandle, &pRes)))
  2856.                         { 
  2857.                             //if(DXCC_SUCCEEDED(pRes->GetObject( (LPUNKNOWN*) &pD3DMaterial)))
  2858.                             if(DXCC_SUCCEEDED(pRes->QueryObject( IID_ID3DXEffect, (void**) &pD3DMaterial)))
  2859.                             {
  2860.                                 if(DXCC_SUCCEEDED(pMesh->SetAttributedMaterial(iShader, pD3DMaterial)))
  2861.                                 {
  2862.                                     bFoundShader= true;
  2863.                                 }
  2864.                                 DXCC_RELEASE(pD3DMaterial);
  2865.                             }
  2866.                             DXCC_RELEASE(pRes);
  2867.                         }
  2868.                     }
  2869.                 }
  2870.             }
  2871.  
  2872.             if(!bFoundShader)
  2873.             {
  2874.                 hr= pMesh->SetAttributedMaterial(iShader, NULL);
  2875.                 if(DXCC_FAILED(hr))
  2876.                     DXCC_GOTO_EXIT( e_Exit, TRUE);
  2877.             }
  2878.         }
  2879.  
  2880.         hr= pMesh->SetAttributedMaterial(Shaders.length(), NULL);
  2881.         if(DXCC_FAILED(hr))
  2882.             DXCC_GOTO_EXIT( e_Exit, TRUE);
  2883.     }
  2884.     else
  2885.     {
  2886.         hr= pMesh->SetAttributedMaterial(0, NULL);
  2887.         if(DXCC_FAILED(hr))
  2888.             DXCC_GOTO_EXIT( e_Exit, TRUE);
  2889.     }
  2890.  
  2891.  
  2892. e_Exit:
  2893.     DXCC_RELEASE(pRes);
  2894.     DXCC_RELEASE(pD3DMaterial);
  2895.  
  2896.     return hr;
  2897. }
  2898.  
  2899.  
  2900. HRESULT        
  2901. CMayaPreviewPipeline::Material_Save(MObject &node)
  2902. {
  2903.     HRESULT hr= S_OK;
  2904.     MStatus stat= MS::kSuccess;
  2905.     MFnDependencyNode depNode(node);
  2906.     const char *pEffectStr= NULL;
  2907.     MPlug plugResource= depNode.findPlug(DirectXShader::aDXCCHandle);
  2908.     LPDXCCRESOURCE pResource= NULL;
  2909.     LPD3DXEFFECT pEffect= NULL;
  2910.     MFnTypedAttribute tAttr;
  2911.     MFnNumericAttribute nAttr;
  2912.     MObject oFxParamList;
  2913.     DXCCHANDLE hHandle;
  2914.     int iHandle;
  2915.     CDXCCSaveEffectDefaults SaveParams;
  2916.     CPipelineLock SceneLock;
  2917.  
  2918.     SceneReadLock(true, SceneLock);
  2919.  
  2920.     plugResource.getValue(iHandle);
  2921.     hHandle= (DXCCHANDLE)iHandle;
  2922.  
  2923.     hr= AccessManager()->FindResourceByHandle(hHandle, &pResource);
  2924.     if(DXCC_FAILED(hr))
  2925.         DXCC_GOTO_EXIT(e_Exit, TRUE);        
  2926.  
  2927.     if(DXCC_FAILED(pResource->GetObject((LPUNKNOWN*)&pEffect)
  2928.         || (pEffect == NULL)))
  2929.         DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);        
  2930.  
  2931.     {//FILE PATH
  2932.         MPlug plugFilePath= depNode.findPlug(DX_LONG_FXFILE_PATH);
  2933.         if(plugFilePath.isNull())
  2934.         {
  2935.             MObject oFxFilePath= tAttr.create(DX_LONG_FXFILE_PATH, DX_SHORT_FXFILE_PATH, MFnData::Type::kString);
  2936.             CHECK_MSTATUS( tAttr.setHidden( true ) );
  2937.             stat= depNode.addAttribute(oFxFilePath, MFnDependencyNode::kLocalDynamicAttr );
  2938.             plugFilePath= depNode.findPlug(DX_LONG_FXFILE_PATH, &stat);
  2939.         }
  2940.     
  2941.         LPCSTR resourcepath= pResource->GetResourcePath();
  2942.         if(resourcepath)
  2943.         {
  2944.             CHECK_MSTATUS(plugFilePath.setValue(MString(resourcepath)));
  2945.         }
  2946.         else
  2947.         {
  2948.             CHECK_MSTATUS(plugFilePath.setValue(MString("")));
  2949.         }
  2950.  
  2951.     }//END//FILE PATH
  2952.  
  2953.     {//FILE NAME
  2954.         MPlug plugFileName= depNode.findPlug(DX_LONG_FXFILE_NAME);
  2955.         if(plugFileName.isNull())
  2956.         {
  2957.             MObject oFxFileName= tAttr.create(DX_LONG_FXFILE_NAME, DX_SHORT_FXFILE_NAME, MFnData::Type::kString);
  2958.             CHECK_MSTATUS( tAttr.setStorable( false ) );
  2959.             stat= depNode.addAttribute(oFxFileName, MFnDependencyNode::kLocalDynamicAttr );
  2960.             plugFileName= depNode.findPlug(DX_LONG_FXFILE_NAME, &stat);
  2961.         }
  2962.  
  2963.         LPCSTR resourcepath= strrchr(pResource->GetResourcePath(), '\\');
  2964.         if(resourcepath)
  2965.             resourcepath++;
  2966.         else
  2967.             resourcepath= pResource->GetResourcePath();
  2968.  
  2969.         CHECK_MSTATUS(plugFileName.setValue(MString(resourcepath)));
  2970.     }//END//FILE NAME
  2971.  
  2972.     {//PARAMTER COUNT
  2973.         MPlug plugParamCount= depNode.findPlug(DX_LONG_FXPARAM_COUNT);
  2974.         if(!plugParamCount.isNull())
  2975.         {
  2976.             int count;
  2977.             plugParamCount.getValue(count);
  2978.  
  2979.             for(int p= 0; p < count; p++)
  2980.             {
  2981.                 MObject oName= depNode.attribute(MString(DX_LONG_FXPARAM_NAME)+p, &stat);
  2982.                 MObject oData= depNode.attribute(MString(DX_LONG_FXPARAM_DATA)+p, &stat);
  2983.                 
  2984.                 if(!oName.isNull())
  2985.                     stat= depNode.removeAttribute(oName);
  2986.                 if(!oData.isNull())
  2987.                     stat= depNode.removeAttribute(oData);
  2988.             }
  2989.         }
  2990.         else
  2991.         {
  2992.             oFxParamList= nAttr.create(DX_LONG_FXPARAM_COUNT, DX_SHORT_FXPARAM_COUNT,MFnNumericData::Type::kInt, SaveParams.iParameter+1, &stat);
  2993.             CHECK_MSTATUS( nAttr.setHidden( true ) );
  2994.             CHECK_MSTATUS(depNode.addAttribute(oFxParamList, MFnDependencyNode::kLocalDynamicAttr));
  2995.         }
  2996.         plugParamCount= depNode.findPlug(DX_LONG_FXPARAM_COUNT);
  2997.  
  2998.         hr= SaveParams.Set(AccessManager(), node);
  2999.         if(DXCC_FAILED(hr))
  3000.             DXCC_GOTO_EXIT(e_Exit, TRUE);
  3001.  
  3002.         hr= DXCCEnumEffectParameters(pEffect, &SaveParams, true, true);
  3003.         if(DXCC_FAILED(hr))
  3004.             DXCC_GOTO_EXIT(e_Exit, TRUE);
  3005.  
  3006.         CHECK_MSTATUS(plugParamCount.setValue((int)(SaveParams.iParameter+1)));
  3007.     }//END//PARAMTER COUNT
  3008.     
  3009. e_Exit:
  3010.     DXCC_RELEASE(pResource);
  3011.     DXCC_RELEASE(pEffect);
  3012.     
  3013.     SceneReadUnlock(SceneLock);
  3014.  
  3015.     return hr;
  3016. }
  3017.  
  3018. HRESULT        
  3019. CMayaPreviewPipeline::Material_Restore(MObject &node)
  3020. {
  3021.     HRESULT hr= S_OK;
  3022.     MStatus stat= MS::kSuccess;
  3023.     
  3024.     MFnDependencyNode depNode(node);
  3025.  
  3026.     LPCSTR pFXFilePath= NULL;
  3027.     LPDIRECT3DDEVICE9 pd3dDevice= NULL;
  3028.     LPDXCCRESOURCE pResource= NULL;
  3029.     LPD3DXEFFECT pEffect= NULL;
  3030.  
  3031.     LPDXCCRESOURCE pResTexture= NULL;
  3032.     LPDIRECT3DCUBETEXTURE9 pTextureCube= NULL;
  3033.     LPDIRECT3DVOLUMETEXTURE9 pTexture3D= NULL;
  3034.     LPDIRECT3DTEXTURE9 pTexture2D= NULL;
  3035.     LPD3DXBUFFER pErrors= NULL;
  3036.     WIN32_FIND_DATAA FindFileData;
  3037.     HANDLE hFind;
  3038.     LPCSTR pFXFileFound= NULL;
  3039.  
  3040.     {//FILEPATH FILENAME
  3041.         MObject oFilePath;
  3042.         MPlug plugFilePath= depNode.findPlug(DX_LONG_FXFILE_PATH);
  3043.         if(MAYA_FAILED( plugFilePath.getValue(oFilePath)))
  3044.             return S_OK;
  3045.  
  3046.         MFnStringData sFilePathData(oFilePath);
  3047.         pFXFilePath= sFilePathData.string().asChar();
  3048.     }//END//FILEPATH
  3049.  
  3050.     MPlug plugParamCount= depNode.findPlug(DX_LONG_FXPARAM_COUNT);
  3051.  
  3052.     if(pFXFilePath && (pFXFilePath[0] != '\0') && !plugParamCount.isNull())
  3053.     {
  3054.         INT cParamCount;
  3055.         int iHandle= NULL;
  3056.         DXCCHANDLE hHandle= NULL;
  3057.         LPCSTR pFXFileName= NULL;
  3058.  
  3059.         {//FILENAME
  3060.             MPlug plugFileName= depNode.findPlug(DX_LONG_FXFILE_NAME);
  3061.     
  3062.             pFXFileName= strrchr(pFXFilePath, '\\');
  3063.             if(pFXFileName)
  3064.                 pFXFileName++;
  3065.             else
  3066.                 pFXFileName= pFXFilePath;
  3067.  
  3068.             plugFileName.setValue(MString(pFXFileName));
  3069.         }//END//FILENAME
  3070.  
  3071.         MPlug plugResource= depNode.findPlug(DirectXShader::aDXCCHandle);
  3072.         if(MAYA_SUCCEEDED(plugResource.getValue(iHandle)))
  3073.         {
  3074.             hHandle= (DXCCHANDLE)iHandle;
  3075.  
  3076.             if(!DXCC_SUCCEEDED(AccessManager()->FindResourceByHandle(hHandle, &pResource)))
  3077.             {
  3078.                 hr= AccessManager()->CreateResource(NULL, IID_ID3DXEffect, true, &pResource);
  3079.                 if(DXCC_FAILED(hr))
  3080.                     DXCC_GOTO_EXIT(e_Exit, TRUE);
  3081.             }
  3082.  
  3083.             AccessEngine()->GetD3DDevice(&pd3dDevice);
  3084.             if(DXCC_FAILED(hr))
  3085.                 DXCC_GOTO_EXIT(e_Exit, TRUE);
  3086.  
  3087.  
  3088.             hFind= FindFirstFileA(pFXFilePath, &FindFileData);
  3089.             if(INVALID_HANDLE_VALUE != hFind)
  3090.             {
  3091.                 FindClose(hFind);
  3092.                 pFXFileFound= pFXFilePath;
  3093.             }
  3094.             else 
  3095.             {
  3096.                 hFind= FindFirstFileA(pFXFileName, &FindFileData);
  3097.  
  3098.                 if(INVALID_HANDLE_VALUE != hFind)
  3099.                 {
  3100.                     FindClose(hFind);
  3101.                     pFXFileFound= pFXFileName;
  3102.                 }
  3103.                 else
  3104.                 {    
  3105.                     MString ErrorMsg= depNode.name() + MString(" cannot load shader - ") + MString(pFXFilePath);
  3106.                     MessageBoxA(NULL, "Shader FX file cannot be found!" , ErrorMsg.asChar(), MB_ICONEXCLAMATION);
  3107.                     DXCC_STATUS_EXIT(hr, S_OK, e_Exit, FALSE);
  3108.                 }
  3109.             }
  3110.  
  3111.             if(!DXCC_SUCCEEDED(D3DXCreateEffectFromFileA(
  3112.                     pd3dDevice,
  3113.                     pFXFileFound,
  3114.                     NULL,
  3115.                     NULL,
  3116.                     NULL,
  3117.                     NULL,
  3118.                     &pEffect,
  3119.                     &pErrors)))
  3120.             {
  3121.                 MessageBoxA(NULL,
  3122.                             (LPCSTR)pErrors->GetBufferPointer(),
  3123.                             "Effect Load Error",
  3124.                             MB_ICONEXCLAMATION);
  3125.                 DXCC_RELEASE(pErrors);
  3126.                 DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, FALSE);
  3127.             }
  3128.  
  3129.             hr= AccessManager()->RecycleResource(pResource->GetHandle(), pEffect, IID_ID3DXEffect, TRUE, FALSE); 
  3130.             if(DXCC_FAILED(hr))
  3131.                 DXCC_GOTO_EXIT(e_Exit, TRUE);
  3132.  
  3133.             hr= pResource->SetName(MakeNameExportable(depNode.name()).asChar());
  3134.             if(DXCC_FAILED(hr))
  3135.                 DXCC_GOTO_EXIT(e_Exit, TRUE);
  3136.  
  3137.             hr= pResource->SetResourcePath(pFXFilePath);
  3138.             if(DXCC_FAILED(hr))
  3139.                 DXCC_GOTO_EXIT(e_Exit, TRUE);
  3140.  
  3141.             
  3142.             CHECK_MSTATUS(plugParamCount.getValue(cParamCount));
  3143.  
  3144.             for(UINT i= 0; i < cParamCount; i++)
  3145.             {
  3146.                 MObject oData;
  3147.                 MObject oName;
  3148.                 MString szName;
  3149.                 
  3150.                 DXCC_RELEASE(pResTexture);
  3151.                 DXCC_RELEASE(pTexture2D);
  3152.                 DXCC_RELEASE(pTexture3D);
  3153.                 DXCC_RELEASE(pTextureCube);
  3154.  
  3155.                 MPlug plugName= depNode.findPlug(MString(DX_LONG_FXPARAM_NAME)+i, &stat);
  3156.                 if(!MAYA_SUCCEEDED( stat ))
  3157.                     continue;
  3158.                 MPlug plugData= depNode.findPlug(MString(DX_LONG_FXPARAM_DATA)+i, &stat);
  3159.                 if(!MAYA_SUCCEEDED( stat ))
  3160.                     continue;
  3161.  
  3162.                 stat= plugName.getValue(szName);
  3163.                 if(!MAYA_SUCCEEDED( stat ))
  3164.                     continue;
  3165.                 
  3166.                 stat= plugData.getValue(oData);
  3167.                 if(!MAYA_SUCCEEDED( stat ))
  3168.                     continue;
  3169.  
  3170.                 D3DXHANDLE hHandle= pEffect->GetParameterByName(NULL, szName.asChar());
  3171.                 if(hHandle != NULL)
  3172.                 {
  3173.                     D3DXPARAMETER_DESC ParamDesc;
  3174.                     if(DXCC_SUCCEEDED(pEffect->GetParameterDesc(hHandle, &ParamDesc )))
  3175.                     {
  3176.                         FLOAT fArray[16];
  3177.                         switch(ParamDesc.Class)
  3178.                         {
  3179.                         case D3DXPC_SCALAR:
  3180.                         case D3DXPC_VECTOR:
  3181.                         case D3DXPC_MATRIX_ROWS:
  3182.                         case D3DXPC_MATRIX_COLUMNS:
  3183.                             {
  3184.                                 MFnDoubleArrayData dArrayData(oData);
  3185.                                 MDoubleArray dArray= dArrayData.array();
  3186.  
  3187.                                 for(UINT i= 0; i < dArray.length(); i++)
  3188.                                     fArray[i]= (FLOAT)dArray[i];
  3189.  
  3190.                                 hr= pEffect->SetFloatArray(hHandle, fArray, dArray.length());
  3191.                                 if(DXCC_FAILED(hr))
  3192.                                     DXCC_GOTO_EXIT(e_Exit, TRUE);
  3193.                             }
  3194.                             break;
  3195.                         case D3DXPC_OBJECT:
  3196.                             {
  3197.                                 switch(ParamDesc.Type)
  3198.                                 {
  3199.                                 case D3DXPT_STRING:
  3200.                                     {
  3201.                                         MFnStringData StringData(oData);
  3202.         
  3203.                                         hr= pEffect->SetString(hHandle, StringData.string().asChar());
  3204.                                         if(DXCC_FAILED(hr))
  3205.                                             DXCC_GOTO_EXIT(e_Exit, TRUE);
  3206.                                     }
  3207.                                     break;
  3208.                                 case D3DXPT_TEXTURE:
  3209.                                 case D3DXPT_TEXTURE1D:
  3210.                                 case D3DXPT_TEXTURE2D:
  3211.                                 case D3DXPT_TEXTURE3D:
  3212.                                 case D3DXPT_TEXTURECUBE:
  3213.                                     {
  3214.                                         D3DXIMAGE_INFO info;
  3215.                                         MFnStringData ParamStringData(oData);
  3216.                                         const char* pParamStr= ParamStringData.string().asChar();
  3217.  
  3218.                                         if(DXCC_SUCCEEDED(D3DXGetImageInfoFromFileA( pParamStr, &info)))
  3219.                                         {
  3220.                                             switch(info.ResourceType)
  3221.                                             {
  3222.                                             case D3DRTYPE_TEXTURE:
  3223.                                                 {
  3224.                                                     hr= D3DXCreateTextureFromFileA(         
  3225.                                                             pd3dDevice,
  3226.                                                             pParamStr,
  3227.                                                             &pTexture2D);
  3228.                                                     if(DXCC_FAILED(hr))
  3229.                                                         DXCC_GOTO_EXIT(e_Exit, TRUE);
  3230.  
  3231.                                                     hr= AccessManager()->CreateResource(
  3232.                                                             pTexture2D, 
  3233.                                                             IID_IDirect3DTexture9, 
  3234.                                                             TRUE, 
  3235.                                                             &pResTexture);
  3236.                                                     if(DXCC_FAILED(hr))
  3237.                                                         DXCC_GOTO_EXIT(e_Exit, TRUE);
  3238.  
  3239.                                                     hr= pResTexture->SetResourcePath(pParamStr);
  3240.                                                     if(DXCC_FAILED(hr))
  3241.                                                         DXCC_GOTO_EXIT(e_Exit, TRUE);
  3242.  
  3243.                                                     hr= pEffect->SetTexture(hHandle, pTexture2D);
  3244.                                                     if(DXCC_FAILED(hr))
  3245.                                                         DXCC_GOTO_EXIT(e_Exit, TRUE);
  3246.  
  3247.                                                 }
  3248.                                                 break;
  3249.                                             case D3DRTYPE_VOLUMETEXTURE:
  3250.                                                 {
  3251.                                                     hr= D3DXCreateVolumeTextureFromFileA(         
  3252.                                                             pd3dDevice,
  3253.                                                             pParamStr,
  3254.                                                             &pTexture3D);
  3255.                                                     if(DXCC_FAILED(hr))
  3256.                                                         DXCC_GOTO_EXIT(e_Exit, TRUE);
  3257.  
  3258.                                                     hr= AccessManager()->CreateResource(
  3259.                                                             pTexture3D, 
  3260.                                                             IID_IDirect3DVolumeTexture9, 
  3261.                                                             TRUE, 
  3262.                                                             &pResTexture);
  3263.                                                     if(DXCC_FAILED(hr))
  3264.                                                         DXCC_GOTO_EXIT(e_Exit, TRUE);
  3265.  
  3266.                                                     hr= pResTexture->SetResourcePath(pParamStr);
  3267.                                                     if(DXCC_FAILED(hr))
  3268.                                                         DXCC_GOTO_EXIT(e_Exit, TRUE);
  3269.  
  3270.                                                     hr= pEffect->SetTexture(hHandle, pTexture3D);
  3271.                                                     if(DXCC_FAILED(hr))
  3272.                                                         DXCC_GOTO_EXIT(e_Exit, TRUE);
  3273.                                                 }
  3274.                                                 break;
  3275.                                             case D3DRTYPE_CUBETEXTURE:
  3276.                                                 {
  3277.                                                     hr= D3DXCreateCubeTextureFromFileA(         
  3278.                                                             pd3dDevice,
  3279.                                                             pParamStr,
  3280.                                                             &pTextureCube);
  3281.                                                     if(DXCC_FAILED(hr))
  3282.                                                         DXCC_GOTO_EXIT(e_Exit, TRUE);
  3283.  
  3284.                                                     hr= AccessManager()->CreateResource(
  3285.                                                             pTextureCube, 
  3286.                                                             IID_IDirect3DCubeTexture9, 
  3287.                                                             TRUE, 
  3288.                                                             &pResTexture);
  3289.                                                     if(DXCC_FAILED(hr))
  3290.                                                         DXCC_GOTO_EXIT(e_Exit, TRUE);
  3291.  
  3292.                                                     hr= pResTexture->SetResourcePath(pParamStr);
  3293.                                                     if(DXCC_FAILED(hr))
  3294.                                                         DXCC_GOTO_EXIT(e_Exit, TRUE);
  3295.  
  3296.                                                     hr= pEffect->SetTexture(hHandle, pTextureCube);
  3297.                                                     if(DXCC_FAILED(hr))
  3298.                                                         DXCC_GOTO_EXIT(e_Exit, TRUE);
  3299.                                                 }
  3300.                                                 break;
  3301.                                             };//end switch info.ResourceType
  3302.                                         }//end D3DXGetImageInfoFromFile
  3303.                                     }//end case textures
  3304.                                     break;
  3305.                                 };//end switch object type
  3306.                             }//end case object
  3307.                             break;
  3308.                         case D3DXPC_STRUCT:
  3309.                         default:
  3310.                             DXCC_ASSERT(FALSE);
  3311.                             break;
  3312.                         }; //end switch ParamDesc.Class
  3313.                     }//end GetParameterDesc
  3314.                 }//end hHandle
  3315.             }//end MFnCompoundAttribute child loop
  3316.  
  3317.  
  3318.             Synchronize_Material(hHandle);
  3319.  
  3320.         }//end FindResource
  3321.     }//end aPath is !null
  3322.  
  3323. e_Exit:
  3324.  
  3325.     DXCC_RELEASE(pResTexture);
  3326.     DXCC_RELEASE(pTexture2D);
  3327.     DXCC_RELEASE(pTexture3D);
  3328.     DXCC_RELEASE(pTextureCube);
  3329.  
  3330.     DXCC_RELEASE(pd3dDevice);
  3331.     DXCC_RELEASE(pResource);
  3332.     DXCC_RELEASE(pEffect);
  3333.     DXCC_RELEASE(pErrors);
  3334.  
  3335.     return hr;
  3336. }
  3337.  
  3338.  
  3339. void    
  3340. MeshCleanUserData(
  3341.     LPMESHUSERDATA dxMeshUserData, 
  3342.     UINT cVerticesMaya,
  3343.     UINT cVerticesD3D)    
  3344. { 
  3345.  
  3346.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  3347.  
  3348.     if(new(dxMeshUserData) MeshUserData)
  3349.     {
  3350.         if(cVerticesD3D > MeshGlobal.D3DPointReps.GetCount())
  3351.         {
  3352.             MeshGlobal.D3DPointReps.SetCount(cVerticesD3D);
  3353.             MeshGlobal.VertexD3DToMaya.SetCount(cVerticesD3D);
  3354.         }
  3355.         ///////////NOT NEEDED/////////MAIN FUNCTION CAN DO THIS/////////
  3356.         //we fill unused elements in d3dx with all 'f's
  3357.         //FillMemory((DWORD*)MeshGlobal.D3DPointReps.GetData(), cVerticesD3D*sizeof(DWORD), 0xff);//fill minimum needed
  3358.  
  3359.         ///////////NOT NEEDED/////////MAIN FUNCTION CAN DO THIS/////////
  3360.         //new((VertexD3DToMayaType*)MeshGlobal.VertexD3DToMaya.GetData()) VertexD3DToMayaType[cVerticesD3D];//fill minimum needed
  3361.  
  3362.         if(cVerticesMaya > MeshGlobal.VertexMayaToD3D.GetCount())
  3363.         {
  3364.             MeshGlobal.VertexMayaToD3D.SetCount(cVerticesMaya);
  3365.         }
  3366.  
  3367.         new((VertexD3DToMayaType*)MeshGlobal.VertexMayaToD3D.GetData()) VertexMayaToD3DType[cVerticesMaya];
  3368.  
  3369.     }
  3370.  
  3371.  
  3372.     DXCC_ASSERT_EXCEPTIONS_END()
  3373.  
  3374.     return;
  3375. }
  3376.  
  3377. LPMESHUSERDATA    
  3378. MeshCreateUserData(
  3379.     LPDXCCRESOURCE pRes, 
  3380.     UINT cVerticesMaya,
  3381.     UINT cVerticesD3D)    
  3382. { 
  3383.     //HRESULT hr;
  3384.     LPMESHUSERDATA dxMeshUserData= NULL;
  3385.  
  3386.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  3387.  
  3388.     DWORD size= sizeof(MeshUserData);
  3389.         //+sizeof(DWORD)*cVerticesD3D
  3390.         //+sizeof(MeshUserData::VertexD3DToMayaType)*cVerticesD3D
  3391.         //+sizeof(MeshUserData::VertexMayaToD3DType)*cVerticesMaya;
  3392.         
  3393.     if(DXCC_SUCCEEDED(pRes->CreateUserData(size))
  3394.         && DXCC_SUCCEEDED(pRes->GetUserData(NULL, (void**) &dxMeshUserData, NULL)))
  3395.     {
  3396.         MeshCleanUserData(dxMeshUserData, cVerticesMaya, cVerticesD3D);
  3397.     }
  3398.  
  3399.     DXCC_ASSERT_EXCEPTIONS_END()
  3400.  
  3401.     return dxMeshUserData;
  3402. }
  3403.  
  3404.  
  3405. LPMESHUSERDATA    
  3406. MeshGetUserData(LPDXCCMESH pMesh, LPDXCCMANAGER pDXCCManager)                        
  3407. { 
  3408.     LPDXCCRESOURCE pRes= NULL;
  3409.     LPMESHUSERDATA dxMeshUserData= NULL;
  3410.  
  3411.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  3412.  
  3413.     if(DXCC_SUCCEEDED(pDXCCManager->FindResourceByPointer(pMesh, NULL, &pRes)))
  3414.         pRes->GetUserData(NULL, (void**) &dxMeshUserData, NULL);
  3415.  
  3416.     DXCC_ASSERT_EXCEPTIONS_END()
  3417.  
  3418.     DXCC_RELEASE(pRes);
  3419.     return dxMeshUserData;  
  3420. }
  3421.  
  3422. void DCCTagContainer::MarkAsDirty(DCCTag* tag)
  3423. {
  3424.     if(!tag->Dirty)
  3425.     {
  3426.         tag->Dirty= true;
  3427.         DirtyArray.push_back(tag);
  3428.     }
  3429. }
  3430.  
  3431.  
  3432. void DCCTagContainer::MarkAsClean_SLOW(DCCTag* tag)
  3433. {
  3434.     if(tag->Dirty)
  3435.     {
  3436.         for(UINT i= 0; i < SizeFromDirtyList(); i++)
  3437.         {
  3438.             DCCTag* found= NULL;
  3439.             if(    GetFromDirtyList(i, found)&& 
  3440.                 found == tag)
  3441.             {
  3442.                 MarkAsClean(i);
  3443.                 return;
  3444.             }
  3445.         }
  3446.     }
  3447. }
  3448.  
  3449.  
  3450. void DCCTagContainer::MarkAsDirty(UINT iGlobalTagIndex)
  3451. {
  3452.     DCCTag* tag= NULL;
  3453.     if(Get(iGlobalTagIndex, tag))
  3454.     {
  3455.         MarkAsDirty(tag);
  3456.     }
  3457. }
  3458.  
  3459. void DCCTagContainer::MarkAsClean(UINT iDirtyListIndex)
  3460. {
  3461.     DCCTag* tag= NULL;
  3462.     
  3463.     if(GetFromDirtyList(iDirtyListIndex, tag))
  3464.     {
  3465.         if(tag->Dirty)
  3466.         {
  3467.             tag->Dirty=false;
  3468.             DirtyArray.erase(DirtyArray.begin()+iDirtyListIndex);
  3469.         }
  3470.     }
  3471. }
  3472.  
  3473.  
  3474. bool DCCTagContainer::IsDirty(DCCTag* tag)
  3475. {
  3476.     return tag->Dirty;
  3477. }
  3478.  
  3479. HRESULT    CMayaPreviewPipeline::Mesh_FindSkin(MFnMesh& InOutMesh, MFnSkinCluster& SkinCluster)
  3480. {
  3481.     HRESULT hr = S_OK;
  3482.     MStatus stat = MS::kSuccess;
  3483.  
  3484.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  3485.  
  3486.     MItDependencyGraph FindSkin(    InOutMesh.object(), 
  3487.                                     MFn::kSkinClusterFilter, 
  3488.                                     MItDependencyGraph::Direction::kUpstream,
  3489.                                     MItDependencyGraph::Traversal::kBreadthFirst,
  3490.                                     MItDependencyGraph::Level::kNodeLevel, 
  3491.                                     &stat);
  3492.     if(MAYA_SUCCEEDED(stat))
  3493.     {
  3494.         MItDependencyGraph FindMesh(    FindSkin.thisNode(), 
  3495.                                         MFn::kMesh, 
  3496.                                         MItDependencyGraph::Direction::kUpstream,
  3497.                                         MItDependencyGraph::Traversal::kBreadthFirst,
  3498.                                         MItDependencyGraph::Level::kNodeLevel, 
  3499.                                         &stat);
  3500.         if(MAYA_FAILED(stat))
  3501.             DXCC_STATUS_EXIT(hr, S_OK, e_Exit, TRUE);
  3502.         //Exit if we couldnt find the original Mesh
  3503.  
  3504.         SkinCluster.setObject(FindSkin.thisNode());
  3505.         
  3506.         InOutMesh.setObject(FindMesh.thisNode());
  3507.     }
  3508.  
  3509.     DXCC_ASSERT_EXCEPTIONS_END()
  3510.  
  3511. e_Exit:
  3512.     return hr;
  3513. }
  3514.  
  3515. HRESULT    CMayaPreviewPipeline::Mesh_GatherSkin(DCCTag *pTag, MFnSkinCluster& SkinCluster)
  3516. {
  3517.     HRESULT hr = S_OK;
  3518.     MStatus stat = MS::kSuccess;
  3519.     LPDXCCMESH dxMesh= NULL;
  3520.     DCCTag *pParentTag= NULL;
  3521.     LPMESHUSERDATA    dxMeshUserData= NULL;
  3522.     MMatrix            MatrixToMesh;                        
  3523.  
  3524.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  3525.  
  3526.     if(SkinCluster.object().isNull())
  3527.         return hr;
  3528.  
  3529.     MDagPath dagParent= pTag->GetPath();
  3530.     dagParent.pop();
  3531.  
  3532.     if(!TagContainer.Find(dagParent, NULL, &pParentTag))
  3533.         DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  3534.  
  3535.     MatrixToMesh= dagParent.exclusiveMatrix();
  3536.  
  3537.     hr= pTag->Resource->GetUserData(NULL, (void**) &dxMeshUserData, NULL);
  3538.     if(DXCC_SUCCEEDED(hr))
  3539.     {
  3540.         pTag->Interface->AddRef();
  3541.         dxMesh= (LPDXCCMESH)pTag->Interface;
  3542.  
  3543.         if(MAYA_SUCCEEDED(stat))
  3544.         {
  3545.             MDagPathArray bones;
  3546.             UINT cBones;
  3547.  
  3548.             cBones= SkinCluster.influenceObjects(bones, &stat);
  3549.             if(cBones > 0)
  3550.             {
  3551.                 hr= dxMesh->CreateBones(cBones);
  3552.                 if(DXCC_FAILED(hr))
  3553.                     DXCC_GOTO_EXIT(e_Exit, TRUE);
  3554.  
  3555.                 for(UINT iBone= 0; iBone < cBones; iBone++)
  3556.                 {
  3557.                     MSelectionList    SelectionInfo;
  3558.                     MFloatArray        Weights;
  3559.                     MFnTransform    fnBone;
  3560.                     DCCTag*            pBoneTag= NULL;
  3561.  
  3562.                     //MObject            VertexSets;
  3563.                     //UINT            iWeight;
  3564.                     MPlug            PlugToBindPose;
  3565.                     MObject            MObjectToBindPose;
  3566.                     //MMatrix            WorldWorldBindMatrix;
  3567.  
  3568.  
  3569.                     DXCC_DPFA("Processing SkinCluster Bone: %s", bones[iBone].partialPathName().asChar());
  3570.  
  3571.                     //Get d3d bone
  3572.                     if(!TagContainer.Find(bones[iBone], NULL, &pBoneTag))
  3573.                     {
  3574.                         DXCC_DPF_ERROR(TEXT("Could not find bone"));
  3575.                         DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  3576.                     }
  3577.  
  3578.                     //Get maya bone
  3579.                     stat = fnBone.setObject(bones[iBone]);
  3580.                     if(MAYA_FAILED(stat))
  3581.                     {
  3582.                         DXCC_DPF_ERROR(TEXT("Could not create transform"));
  3583.                         DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  3584.                     }
  3585.  
  3586.                     //get influences
  3587.                     stat = SkinCluster.getPointsAffectedByInfluence(bones[iBone], SelectionInfo, Weights);
  3588.                     if(MAYA_FAILED(stat))
  3589.                     {
  3590.                         DXCC_DPF(TEXT("Ignoring bone because failure on getPointsAffectedByInfluence."));
  3591.                         DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  3592.                     }
  3593.  
  3594.                     {//BIND POSE
  3595.  
  3596.                         MMatrix            MatrixToBindPose;
  3597.                         MMatrix            MatrixOfBoneOffset;
  3598.                         MFnMatrixData    MatrixDataToBindPose;
  3599.                         D3DXMATRIX        matBoneOffset;
  3600.  
  3601.                         MObjectToBindPose = MObject::kNullObj;
  3602.  
  3603.                         PlugToBindPose = fnBone.findPlug("bindPose", &stat);
  3604.                         if(MAYA_FAILED(stat)) // success
  3605.                         {
  3606.                             DXCC_DPF_ERROR(TEXT("Could not get Pose Plug"));
  3607.                             DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  3608.                         }
  3609.  
  3610.                         stat = PlugToBindPose.getValue(MObjectToBindPose);
  3611.                         if(MAYA_FAILED(stat))
  3612.                         {
  3613.                             DXCC_DPF_ERROR(TEXT("Could not get Pose Plug WorldWorldBindMatrix MObject"));
  3614.                             DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  3615.                         }
  3616.  
  3617.                         stat = MatrixDataToBindPose.setObject(MObjectToBindPose);
  3618.                         if(MAYA_FAILED(stat))
  3619.                         {
  3620.                             DXCC_DPF_ERROR(TEXT("Could not get WorldWorldBindMatrix FnMatrixData interface"));
  3621.                             DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  3622.                         }
  3623.  
  3624.                         MatrixToBindPose= MatrixDataToBindPose.matrix();
  3625.  
  3626.                         MatrixOfBoneOffset= MatrixToMesh * MatrixToBindPose.inverse();
  3627.  
  3628.                         ConvertLocalMatrix(matBoneOffset, MatrixOfBoneOffset);
  3629.                     
  3630.                         dxMesh->SetBoneFrame(iBone, (LPDXCCFRAME)pBoneTag->Interface, NULL);
  3631.                         dxMesh->SetBoneOffsetMatrix(iBone, &matBoneOffset);
  3632.                     }//END//BIND POSE
  3633.  
  3634.  
  3635.                     //WEIGHTS
  3636.                     if(SelectionInfo.length() == 0)
  3637.                     {
  3638.                         for (UINT iWeight = 0; iWeight < dxMesh->NumVertices(); iWeight++)
  3639.                         {
  3640.                             dxMesh->SetBoneInfluence(iBone, iWeight, 0.0f);
  3641.                         };
  3642.                     }
  3643.                     else
  3644.                     {
  3645.                         for(UINT iInfluenceComponents= 0; iInfluenceComponents < SelectionInfo.length(); iInfluenceComponents++)
  3646.                         {
  3647.                             MDagPath dagMesh;
  3648.                             MObject components;
  3649.  
  3650.                             //get mesh and vertices from selection data
  3651.                             stat = SelectionInfo.getDagPath(iInfluenceComponents, dagMesh, components);
  3652.                             if(MAYA_FAILED(stat))
  3653.                             {
  3654.                                 DXCC_DPF_ERROR(TEXT("Could not read DAG Path from SkinCluster  =SelectioInfo"));
  3655.                                 DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  3656.                             }
  3657.                             else
  3658.                             {
  3659.                                 UINT iWeight = 0;
  3660.                                 MItGeometry itVertices(dagMesh, components);
  3661.                                 for (; !itVertices.isDone(); itVertices.next(), iWeight++)
  3662.                                 {
  3663.                                     FLOAT Weight= Weights[iWeight]; 
  3664.  
  3665.                                     for(DWORD iVertexD3D= MeshGlobal.VertexMayaToD3D[itVertices.index()].D3DFirstPointRep;
  3666.                                         iVertexD3D != UNUSED32;
  3667.                                         iVertexD3D= MeshGlobal.VertexD3DToMaya[iVertexD3D].D3DNextPointRep)
  3668.                                     {
  3669.                                         dxMesh->SetBoneInfluence(iBone, iVertexD3D, Weight);
  3670.                                     }
  3671.                                 }
  3672.                             }
  3673.                         }
  3674.                     }//END//WEIGHTS
  3675.                 }
  3676.             }
  3677.         }
  3678.     }
  3679.  
  3680.  
  3681. e_Exit:
  3682.     DXCC_RELEASE(dxMesh);
  3683.  
  3684.     DXCC_ASSERT_EXCEPTIONS_END()
  3685.  
  3686.     return hr;
  3687. }
  3688.  
  3689. HRESULT CMayaPreviewPipeline::Frame_GatherAnimation(DCCTag* pTag)
  3690. {
  3691.     HRESULT hr= S_OK;
  3692.     MStatus stat = MS::kSuccess;
  3693.  
  3694.     LPDXCCFRAME pFrame= NULL;
  3695.     LPDXCCANIMATIONSTREAM pAnim= NULL;
  3696.     if(!pTag)
  3697.         return E_FAIL;
  3698.  
  3699.     if(!pTag->Resource)
  3700.         return E_FAIL;
  3701.  
  3702.     if(pTag->Resource->GetIID() != IID_IDXCCFrame)
  3703.         return E_FAIL;
  3704.  
  3705.     if(!pTag->Interface)
  3706.         return E_FAIL;
  3707.  
  3708.     MDagPath dagTag= pTag->GetPath();
  3709.     MFnDependencyNode depNode(dagTag.node());
  3710.     MPlug matrixPlug= depNode.findPlug("matrix", &stat);//xformMatrix
  3711.     UINT minTick= (UINT)MAnimControl::minTime().as(MTime::uiUnit());
  3712.     UINT maxTick= (UINT)MAnimControl::maxTime().as(MTime::uiUnit());
  3713.     UINT cTicks= maxTick-minTick;
  3714.     UINT nFPS= MayaGetFPS();
  3715.  
  3716.     pFrame= (LPDXCCFRAME)pTag->Interface;
  3717.     pFrame->AddRef();
  3718.  
  3719.     hr= pFrame->GetLocalAnimation(&pAnim);
  3720.     if(DXCC_FAILED(hr))
  3721.         DXCC_GOTO_EXIT(e_Exit, TRUE);
  3722.  
  3723.     hr= pAnim->CreateTransformKeys(nFPS, D3DXPLAY_ONCE, cTicks);
  3724.     if(DXCC_FAILED(hr))
  3725.         DXCC_GOTO_EXIT(e_Exit, TRUE);
  3726.     
  3727.     for(UINT iTick= 0; iTick < cTicks; iTick++)
  3728.     {
  3729.         MObject matrixObject;
  3730.         DXCCKEY_MATRIX matrixKey;
  3731.         matrixKey.Time= (double)(minTick+iTick);
  3732.  
  3733.         MDGContext timeContext(MTime(matrixKey.Time, MTime::uiUnit()));
  3734.         stat= matrixPlug.getValue(matrixObject, timeContext);
  3735.  
  3736.         MFnMatrixData matrixData(matrixObject, &stat);
  3737.  
  3738.         ConvertLocalMatrix(matrixKey.Value, matrixData.matrix());
  3739.  
  3740.         hr= pAnim->SetTransformKeyAsMatrix(iTick, &matrixKey);
  3741.         if(DXCC_FAILED(hr))
  3742.             DXCC_GOTO_EXIT(e_Exit, TRUE);
  3743.  
  3744.     }
  3745.  
  3746. e_Exit:
  3747.     DXCC_RELEASE(pFrame);
  3748.     DXCC_RELEASE(pAnim);
  3749.     return hr;
  3750. }
  3751.  
  3752.  
  3753.  
  3754.  
  3755. //
  3756. //HRESULT 
  3757. //MayaMeshHierarchy::SceneAddAnimationFixedStep()
  3758. //{
  3759. //    HRESULT    hr = S_OK;
  3760. //    MStatus stat = MS::kSuccess;
  3761. //
  3762. //    //MAnimControl mAnimCtrl;
  3763. //    MTime mtTick, mtOriginalTime;
  3764. //    LONG nTicks;
  3765. //    LPDXCCFRAME pITFrame= NULL;
  3766. //    LPDXCCFRAMEITERATOR pIT = NULL;
  3767. //    DWORD nFPS= MayaGetFPS();
  3768. //
  3769. //    hr= DXCCCreateFrameIterator(&pIT);
  3770. //    if(DXCC_FAILED(hr))
  3771. //        DXCC_GOTO_EXIT(e_Exit, TRUE);
  3772. //
  3773. //    mtOriginalTime = MAnimControl::currentTime();
  3774. //
  3775. //    nTicks= (LONG)(MAnimControl::maxTime()-MAnimControl::minTime()).value()+1;
  3776. //
  3777. //    //Initialize frames
  3778. //    
  3779. //    for(pIT->Reset(pRoot, DXCCITERATOR_DEPTHFIRST), pIT->Next(); !pIT->Done(); pIT->Next())
  3780. //    {
  3781. //        LPFRAMEUSERDATA pFrameUD;
  3782. //
  3783. //        hr= pIT->Get(&pITFrame);
  3784. //        if(DXCC_FAILED(hr))
  3785. //            DXCC_GOTO_EXIT(e_Exit, TRUE);
  3786. //
  3787. //        pFrameUD= FrameGetUserData(pITFrame, pDXCCManager);
  3788. //
  3789. //        //if(MAnimUtil::isAnimated(pFrameUD->dagPath))
  3790. //        if(pFrameUD->dagPath.hasFn(MFn::kTransform))
  3791. //        {
  3792. //            
  3793. //            LPDXCCANIMATIONSTREAM pAnimation= NULL;
  3794. //            hr= pITFrame->GetLocalAnimation(&pAnimation);
  3795. //            if(DXCC_FAILED(hr))
  3796. //                DXCC_GOTO_EXIT(e_Exit, TRUE);
  3797. //
  3798. //            hr= pAnimation->CreateTransformKeys(nFPS, D3DXPLAY_ONCE, nTicks);
  3799. //            if(DXCC_FAILED(hr))
  3800. //                DXCC_GOTO_EXIT(e_Exit, TRUE);
  3801. //
  3802. //            DXCC_RELEASE(pAnimation);
  3803. //        }
  3804. //
  3805. //        DXCC_RELEASE(pITFrame);
  3806. //    }
  3807. //
  3808. //    for (mtTick = MAnimControl::minTime(); mtTick <= MAnimControl::maxTime(); mtTick += 1)
  3809. //    {
  3810. //        LONG iTick= (LONG)mtTick.value() - (LONG)MAnimControl::minTime().value();
  3811. //
  3812. //        stat= MAnimControl::setCurrentTime(mtTick);
  3813. //        if(MAYA_FAILED(stat))
  3814. //            DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  3815. //
  3816. //        for(pIT->Reset(pRoot, DXCCITERATOR_DEPTHFIRST), pIT->Next(); !pIT->Done(); pIT->Next())
  3817. //        {
  3818. //            LPFRAMEUSERDATA pFrameUD;
  3819. //
  3820. //            hr= pIT->Get(&pITFrame);
  3821. //            if(DXCC_FAILED(hr))
  3822. //                DXCC_GOTO_EXIT(e_Exit, TRUE);
  3823. //            
  3824. //            pFrameUD= FrameGetUserData(pITFrame, pDXCCManager);
  3825. //            if(pFrameUD->dagPath.hasFn(MFn::kTransform))
  3826. //            {
  3827. //                hr= FrameAddAnimationFixedStep(iTick, pITFrame);
  3828. //                if(DXCC_FAILED(hr))
  3829. //                    DXCC_GOTO_EXIT(e_Exit, TRUE);
  3830. //            }
  3831. //
  3832. //            DXCC_RELEASE(pITFrame);
  3833. //        }
  3834. //    }
  3835. //
  3836. //e_Exit:
  3837. //    DXCC_RELEASE(pITFrame);
  3838. //    DXCC_RELEASE(pIT);
  3839. //
  3840. //    // reset current time
  3841. //    MAnimControl::setCurrentTime(mtOriginalTime);
  3842. //
  3843. //    return hr;
  3844. //}
  3845. //
  3846. //HRESULT 
  3847. //MayaMeshHierarchy::FrameAddAnimationFixedStep(
  3848. //    LONG iTick, 
  3849. //    LPDXCCFRAME _pFrame)
  3850. //{
  3851. //    HRESULT    hr = S_OK;
  3852. //    MStatus stat = MS::kSuccess;
  3853. //    MFnTransform fnTransform;
  3854. //    DXCCKEY_MATRIX KeyMatrix;
  3855. //    MMatrix MayaMatrix;
  3856. //    DWORD i, j;            // counters
  3857. //    LPDXCCANIMATIONSTREAM pAnimation= NULL;
  3858. //    DWORD nFPS= MayaGetFPS();
  3859. //    MDagPath FramePath;
  3860. //
  3861. //    LPFRAMEUSERDATA pFrameUD= FrameGetUserData(_pFrame, pDXCCManager);
  3862. //    //MDagPath::getAPathTo(pFrameUD->object, FramePath);
  3863. //    FramePath= pFrameUD->dagPath;
  3864. //
  3865. //    if(!FramePath.hasFn(MFn::kTransform))
  3866. //        DXCC_GOTO_EXIT( e_Exit, FALSE);
  3867. //
  3868. //    //if(MAnimUtil::isAnimated(pFrameUD->dagPath))
  3869. //    //    DXCC_GOTO_EXIT( e_Exit, FALSE);
  3870. //
  3871. //    hr= _pFrame->GetLocalAnimation(&pAnimation);
  3872. //    if(DXCC_SUCCEEDED(hr))
  3873. //    {
  3874. //        stat = fnTransform.setObject(FramePath);
  3875. //        if(MAYA_FAILED(stat))
  3876. //            DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  3877. //
  3878. //
  3879. //        KeyMatrix.Time= (FLOAT)iTick;///(float)nFPS;
  3880. //
  3881. //        MayaMatrix= fnTransform.transformation().asMatrix();
  3882. //        for (i = 0; i < 4; i++)
  3883. //            for (j = 0; j < 4; j++)
  3884. //                KeyMatrix.Value[i * 4 + j]= (FLOAT)MayaMatrix(i, j);
  3885. //
  3886. //        hr= pAnimation->SetTransformKeyAsMatrix(iTick, &KeyMatrix);
  3887. //        if(DXCC_FAILED(hr))
  3888. //            DXCC_GOTO_EXIT(e_Exit, TRUE);
  3889. //    }
  3890. //
  3891. //e_Exit:
  3892. //    DXCC_RELEASE(pAnimation);
  3893. //    return hr;
  3894. //};
  3895. //
  3896. //
  3897. //HRESULT 
  3898. //MayaMeshHierarchy::SceneAddAnimationKeys()
  3899. //{
  3900. //    HRESULT    hr = S_OK;
  3901. //    MStatus stat = MS::kSuccess;
  3902. //    LPDXCCFRAME pITFrame= NULL;
  3903. //    LPDXCCFRAMEITERATOR pIT= NULL;
  3904. //    MAnimControl mAnimCtrl;
  3905. //
  3906. //    hr= DXCCCreateFrameIterator(&pIT);
  3907. //    if(DXCC_FAILED(hr))
  3908. //        DXCC_GOTO_EXIT(e_Exit, TRUE);
  3909. //
  3910. //
  3911. //    for(pIT->Reset(pRoot, DXCCITERATOR_DEPTHFIRST), pIT->Next(); !pIT->Done(); pIT->Next())
  3912. //    {
  3913. //        hr= pIT->Get(&pITFrame);
  3914. //        if(DXCC_FAILED(hr))
  3915. //            DXCC_GOTO_EXIT(e_Exit, TRUE);
  3916. //
  3917. //        hr= FrameAddAnimationKeys(pITFrame);
  3918. //        if(DXCC_FAILED(hr))
  3919. //            DXCC_GOTO_EXIT(e_Exit, TRUE);
  3920. //
  3921. //        DXCC_RELEASE(pITFrame);
  3922. //    }
  3923. //
  3924. //e_Exit:
  3925. //    DXCC_RELEASE(pITFrame);
  3926. //    DXCC_RELEASE(pIT);
  3927. //
  3928. //    return hr;
  3929. //}
  3930. //
  3931. //HRESULT 
  3932. //MayaMeshHierarchy::FrameAddAnimationKeys(
  3933. //    LPDXCCFRAME _pFrame)
  3934. //{
  3935. //    HRESULT    hr = S_OK;
  3936. //    MStatus stat = MS::kSuccess;
  3937. ////
  3938. ////    DWORD nFPS= MayaGetFPS();
  3939. ////    MAnimControl mAnimCtrl;
  3940. ////    MTime mtTick;
  3941. ////    MTime mtOriginalTime;
  3942. ////    MFnTransform fnTransform;
  3943. ////    MPlugArray AnimPlugs;
  3944. ////    UINT iPlug, iCurve, i, j;
  3945. ////    BOOL* rgbKeyedFrames;
  3946. ////    UINT iKey, nKeys, iTick, nTicks= (UINT)(MAnimControl::maxTime()-MAnimControl::minTime()).value()+1;
  3947. ////    MMatrix MayaMatrix;
  3948. ////    LPDXCCANIMATIONSTREAM pAnimation;
  3949. ////    MDagPath FramePath;
  3950. ////
  3951. ////    LPFRAMEUSERDATA pFrameUD= FrameGetUserData(_pFrame);
  3952. ////    //MDagPath::getAPathTo(pFrameUD->object, FramePath);
  3953. ////    FramePath= pFrameUD->dagPath;
  3954. ////
  3955. ////    if(MAnimUtil::isAnimated(pFrameUD->dagPath))
  3956. ////        DXCC_GOTO_EXIT( e_Exit, FALSE);
  3957. ////
  3958. ////    mtOriginalTime = mAnimCtrl.currentTime();
  3959. ////
  3960. ////    stat = fnTransform.setObject(FramePath);
  3961. ////    if(MAYA_FAILED(stat))
  3962. ////        DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  3963. ////
  3964. ////    MAnimUtil::findAnimatedPlugs(FramePath, AnimPlugs, false, &stat);
  3965. ////    if(MAYA_FAILED(stat))
  3966. ////        DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  3967. ////
  3968. ////    //COUNT AND FLAG THE KEYS
  3969. ////    //MAYA IS MORE COMPLICATED THAN SRT SO WE WILL JUST CAPTURE THE WHOLE MATRIX ON ANY KEY
  3970. ////    rgbKeyedFrames= (BOOL*)_alloca(sizeof(BOOL)*nTicks);
  3971. ////    nKeys= 0;
  3972. ////    for (nKeys= 0, iPlug = 0; iPlug < AnimPlugs.length(); iPlug++)
  3973. ////    {
  3974. ////        MObjectArray Curves;
  3975. ////
  3976. ////        MAnimUtil::findAnimation(AnimPlugs[iPlug], Curves, &stat);
  3977. ////        if(MAYA_FAILED(stat))
  3978. ////        {
  3979. ////            DXCC_DPF(TEXT("Ignoring anim-plug because could not find animation."));
  3980. ////            continue;
  3981. ////        }
  3982. ////
  3983. ////        for (iCurve = 0; iCurve < Curves.length(); iCurve++)
  3984. ////        {
  3985. ////            MFnAnimCurve fnCurve(Curves[iCurve], &stat);
  3986. ////            if(MAYA_FAILED(stat))
  3987. ////                DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  3988. ////
  3989. ////            for (iKey = 0; iKey < fnCurve.numKeys(); iKey++)
  3990. ////            {
  3991. ////                MTime mtTime = fnCurve.time(iKey, &stat);
  3992. ////                if(MAYA_FAILED(stat))
  3993. ////                    DXCC_STATUS_EXIT(hr, E_FAIL, e_Exit, TRUE);
  3994. ////
  3995. ////                rgbKeyedFrames[(LONG)mtTime.value()]= TRUE;
  3996. ////                nKeys++;
  3997. ////            }
  3998. ////        }
  3999. ////    }
  4000. ////
  4001. ////    hr= DXCCCreateAnimationStreamForMatrices(nKeys, &pAnimation);
  4002. ////    if(DXCC_FAILED(hr))
  4003. ////        DXCC_GOTO_EXIT(e_Exit, TRUE);
  4004. ////
  4005. ////    hr= _pFrame->SetLocalAnimation(pAnimation);
  4006. ////    if(DXCC_FAILED(hr))
  4007. ////        DXCC_GOTO_EXIT(e_Exit, TRUE);
  4008. ////
  4009. ////    for(iKey= 0, iTick = 0; iTick < nTicks; iTick++)
  4010. ////    {
  4011. ////        if(rgbKeyedFrames[iTick] == TRUE)
  4012. ////        {
  4013. ////            LPDXCCKEY_MATRIX pKeyMatrix;
  4014. ////            hr= pAnimation->GetMatrix(iKey, &pKeyMatrix);
  4015. ////            if(DXCC_FAILED(hr))
  4016. ////                DXCC_GOTO_EXIT(e_Exit, TRUE);
  4017. ////
  4018. ////            pKeyMatrix->Time= iTick/(float)nFPS ;
  4019. ////
  4020. ////            MayaMatrix= fnTransform.transformation().asMatrix();
  4021. ////            for (i = 0; i < 4; i++)
  4022. ////                for (j = 0; j < 4; j++)
  4023. ////                    pKeyMatrix->Value[i * 4 + j]= (FLOAT)MayaMatrix(i, j);
  4024. ////
  4025. ////
  4026. ////            iKey++;
  4027. ////        }
  4028. ////    }
  4029. ////
  4030. ////e_Exit:
  4031. ////    DXCC_RELEASE(pAnimation);
  4032. ////    // reset current time
  4033. ////    mAnimCtrl.setCurrentTime(mtOriginalTime);
  4034. //
  4035. //    return hr;
  4036. //};
  4037.  
  4038.  
  4039.  
  4040.  
  4041.  
  4042.  
  4043.  
  4044.  
  4045.  
  4046.  
  4047.  
  4048.  
  4049.  
  4050.